Ejemplo n.º 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);
  }
Ejemplo n.º 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);
 }
Ejemplo n.º 3
0
  @Test
  public void testNoAdd2WithCircDep() {
    Foo.instanceCounter = 0;
    PetiteContainer pc = new PetiteContainer();
    pc.registerBean(Foo.class);
    pc.registerBean(Zoo.class);
    pc.registerBean(Boo.class);

    Boo boo = (Boo) pc.getBean("boo");
    Foo foo = (Foo) pc.getBean("foo");
    Zoo zoo = (Zoo) pc.getBean("zoo");

    assertNotNull(boo.getFoo());
    assertSame(foo, boo.getFoo());

    assertNotNull(zoo.boo);
    assertSame(boo, zoo.boo);
    assertSame(zoo, boo.zoo);

    Boo boo2 = (Boo) pc.getBean("boo");
    assertNotNull(boo2);
    assertSame(boo, boo2);
    assertFalse(boo.orders.isEmpty());
    assertNotNull(boo2.getFoo());
    assertSame(foo, boo2.getFoo());
    assertEquals(1, boo2.getFoo().hello());
    assertEquals(1, boo2.getFoo().getCounter());
    assertEquals("[first, second, third, init, beforeLast, last]", boo.orders.toString());
  }
Ejemplo n.º 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);
  }
  @Before
  public void init() {

    petite = new PetiteContainer();

    // load parameters
    Props appProps = new Props();
    PropsUtil.loadFromClasspath(appProps, "/props.props");
    petite.defineParameters(appProps);

    // add appCore to Petite (and resolve parameters)
    AutomagicPetiteConfigurator pcfg = new AutomagicPetiteConfigurator();
    pcfg.setIncludedEntries(this.getClass().getPackage().getName() + ".*");
    pcfg.configure(petite);
  }
Ejemplo n.º 6
0
  /**
   * Injects all matching parameters to target instance. Matching parameters are named as given base
   * name.
   *
   * @param scopeData scope data is not used!
   */
  public void injectContext(Target target, ScopeData[] scopeData, PetiteContainer madpc) {
    Class targetType = target.resolveType();
    String baseName = targetType.getName();

    ParamManager madvocPetiteParamManager = madpc.getParamManager();

    String[] params = madvocPetiteParamManager.resolve(baseName, true);

    for (String param : params) {
      Object value = madvocPetiteParamManager.get(param);

      String propertyName = param.substring(baseName.length() + 1);

      target.writeValue(propertyName, value, madvocConfig.isInjectionErrorThrowsException());
    }
  }
Ejemplo n.º 7
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
  }
Ejemplo n.º 8
0
  @Test
  public void testTwo() {
    PetiteContainer pc = new PetiteContainer();
    pc.registerBean(DefaultBizImpl.class);
    assertEquals(1, pc.getTotalBeans());

    Object bizI = pc.getBean("biz");
    assertTrue(bizI instanceof Biz);
    assertFalse(bizI instanceof DefaultBiz);
    assertTrue(bizI instanceof DefaultBizImpl);

    // pc = new PetiteContainer();			// same container!!!
    pc.registerBean(DefaultBiz.class); // override! instance will be removed from the scope
    assertEquals(1, pc.getTotalBeans());
    bizI = pc.getBean("biz");
    assertTrue(bizI instanceof Biz);
    assertFalse(bizI instanceof DefaultBizImpl);
    assertTrue(bizI instanceof DefaultBiz);
  }
 public <T> T getBeen(Class<T> type) {
   return petite.getBean(type);
 }
Ejemplo n.º 10
0
 /** Starts with defining injection points (i.e. wiring) for existing bean. */
 public BeanWire wire(String beanName) {
   petiteContainer.lookupExistingBeanDefinition(beanName);
   return new BeanWire(beanName);
 }
Ejemplo n.º 11
0
  @Test
  public void testOne() {
    PetiteContainer pc = new PetiteContainer();
    pc.registerBean(DefaultBizImpl.class);
    assertEquals(1, pc.getTotalBeans());

    Object bizI = pc.getBean("biz");
    assertTrue(bizI instanceof Biz);
    assertTrue(bizI instanceof DefaultBizImpl);

    pc = new PetiteContainer();
    pc.registerBean(DefaultBizImpl.class);
    pc.registerBean(DefaultBiz.class); // override!
    assertEquals(1, pc.getTotalBeans());
    pc.registerBean(Foo.class);
    pc.registerPropertyInjectionPoint("biz", "foo");
    pc.registerInitMethods("biz", "init", "init2");

    assertEquals(2, pc.getTotalBeans());
    bizI = pc.getBean("biz");
    assertTrue(bizI instanceof Biz);
    assertFalse(bizI instanceof DefaultBizImpl);
    assertTrue(bizI instanceof DefaultBiz);

    assertNotNull(((DefaultBiz) bizI).getFoo());
    assertEquals(2, ((DefaultBiz) bizI).initCount);
  }
Ejemplo n.º 12
0
 /** Initializes business part of the application. Simply delegates to {@link AppInit#init()}. */
 protected void startApp() {
   appInit = (AppInit) petite.getBean(PETITE_INIT);
   if (appInit != null) {
     appInit.init();
   }
 }