Пример #1
0
  /**
   * Creates and initializes Petite container. It will be auto-magically configured by scanning the
   * classpath. Also, all 'app*.prop*' will be loaded and values will be injected in the matched
   * beans. At the end it registers this instance of core into the container.
   */
  protected void startPetite() {
    log.info("petite initialization");
    petite = createPetiteContainer();

    log.info("app in web: " + Boolean.valueOf(isWebApplication));
    if (isWebApplication == false) {
      // make session scope to act as singleton scope
      // if this is not a web application (and http session is not available).
      petite.registerScope(SessionScope.class, new SingletonScope());
    }

    // load parameters from properties files
    petite.defineParameters(appProps);

    // adds a scanner bean, so it can be immediately configured from props
    petite.addBean(PETITE_SCAN, appScanner);

    // automagic configuration
    registerPetiteContainerBeans(petite);

    // add AppCore instance to Petite
    petite.addBean(PETITE_CORE, this);

    petite.addBean(PETITE_PROPS, appProps);
  }
Пример #2
0
 @Test
 public void testAdd() {
   PetiteContainer pc = new PetiteContainer();
   Foo foo = new Foo();
   pc.addBean("foo", foo);
   Foo foo2 = (Foo) pc.getBean("foo");
   assertNotNull(foo2);
   assertSame(foo, foo2);
 }
Пример #3
0
  @Test
  public void testAdd2WithCircDep() {
    Foo.instanceCounter = 0;
    PetiteContainer pc = new PetiteContainer();
    pc.registerBean(Foo.class);
    pc.registerBean(Zoo.class);

    Foo foo = (Foo) pc.getBean("foo");
    Boo boo = new Boo();
    assertNull(boo.getFoo());

    pc.addBean("boo", boo, null);
    assertNotNull(boo.getFoo());
    assertSame(foo, boo.getFoo());
    assertNotNull(boo.zoo);

    Zoo zoo = (Zoo) pc.getBean("zoo");
    assertNotNull(zoo.boo);
    assertSame(zoo, boo.zoo); // circular dependecy
    assertSame(boo, zoo.boo);

    Boo boo2 = (Boo) pc.getBean("boo");
    assertNotNull(boo2);
    assertSame(boo, boo2);
    assertFalse(boo.orders.isEmpty());
    assertEquals(6, boo.orders.size());
    assertEquals("[first, second, third, init, beforeLast, last]", boo.orders.toString());
    assertNotNull(boo2.getFoo());
    assertSame(foo, boo2.getFoo());
    assertEquals(1, boo2.getFoo().hello());
    assertEquals(1, boo2.getFoo().getCounter());

    pc.addBean("boo", boo);
    boo2 = (Boo) pc.getBean("boo");
    assertNotNull(boo2);
    assertSame(boo, boo2);
    assertNotNull(boo2.getFoo());
    assertSame(foo, boo2.getFoo());
    assertEquals(1, boo2.getFoo().hello());
    assertEquals(2, boo2.getFoo().getCounter());
    assertEquals(12, boo.orders.size()); // init methods are called again due to re-add
  }
Пример #4
0
  /**
   * Initializes database. First, creates connection pool. and transaction manager. Then, Jodds
   * DbOomManager is configured. It is also configured automagically, by scanning the class path for
   * entities.
   */
  @SuppressWarnings("unchecked")
  protected void startDb() {
    if (!useDatabase) {
      log.info("database is not used");
      return;
    }

    log.info("database initialization");

    // connection pool
    petite.registerPetiteBean(CoreConnectionPool.class, PETITE_DBPOOL, null, null, false);
    connectionProvider = (ConnectionProvider) petite.getBean(PETITE_DBPOOL);
    connectionProvider.init();

    // transactions manager
    jtxManager = createJtxTransactionManager(connectionProvider);
    jtxManager.setValidateExistingTransaction(true);

    AnnotationTxAdviceManager annTxAdviceManager =
        new AnnotationTxAdviceManager(jtxManager, jtxScopePattern);
    annTxAdviceManager.registerAnnotations(jtxAnnotations);
    AnnotationTxAdviceSupport.manager = annTxAdviceManager;

    DbSessionProvider sessionProvider = new DbJtxSessionProvider(jtxManager);

    // global settings
    DbManager dbManager = DbManager.getInstance();
    dbManager.setConnectionProvider(connectionProvider);
    dbManager.setSessionProvider(sessionProvider);
    petite.addBean(PETITE_DB, dbManager);

    DbOomManager dbOomManager = DbOomManager.getInstance();
    petite.addBean(PETITE_DBOOM, dbOomManager);

    // automatic configuration
    registerDbEntities(dbOomManager);
  }
Пример #5
0
 /**
  * Adds self instance to the container so internal beans may fetch container for further usage. No
  * wiring is used and no init methods are invoked.
  */
 public void addSelf() {
   addBean(PETITE_CONTAINER_REF_NAME, this, WiringMode.NONE);
 }
Пример #6
0
 /**
  * Adds self instance to the container so internal beans may fetch container for further usage. No
  * wiring is used and no init methods are invoked.
  */
 public void addSelf(String name) {
   addBean(name, this, WiringMode.NONE);
 }
Пример #7
0
 /**
  * Adds object instance to the container as singleton bean using default wiring mode and default
  * init method flag.
  */
 public void addBean(String name, Object bean) {
   addBean(name, bean, null);
 }