public JDBCBrokerFactory(JDBCConfiguration conf) 
{
        super(conf);
}

Construct the factory with the given option settings; however, the factory construction methods are recommended.

 public static JDBCBrokerFactory getInstance(ConfigurationProvider cp) 
{
        Map props = cp.getProperties();
        Object key = toPoolKey(props);
        JDBCBrokerFactory factory = (JDBCBrokerFactory)
            getPooledFactoryForKey(key);
        if (factory != null)
            return factory;
        factory = newInstance(cp);
        pool(key, factory);
        return factory;
}

Factory method for obtaining a possibly-pooled factory from properties. Invoked from Bootstrap#getBrokerFactory .

 public Properties getProperties() 
{
        // add platform property
        Properties props = super.getProperties();
        String db = "Unknown";
        try {
            JDBCConfiguration conf = (JDBCConfiguration) getConfiguration();
            db = conf.getDBDictionaryInstance().platform;
        } catch (RuntimeException re) {
        }
        props.setProperty("Platform",
            "OpenJPA JDBC Edition: " + db + " Database");
        return props;
}

 protected BrokerImpl newBrokerImpl(String user,
    String pass) 
{
        BrokerImpl broker = super.newBrokerImpl(user, pass);
        lock();
        try {
            // synchronize mappings; we wait until now to do this so that
            // we can use the first broker user/pass for connection if no
            // global login is given
            if (!_synchronizedMappings) {
                _synchronizedMappings = true;
                synchronizeMappings(broker.getClassLoader());
            }
            return broker;
        } finally {
            unlock();
        }
}

 public static JDBCBrokerFactory newInstance(ConfigurationProvider cp) 
{
                     
        JDBCConfigurationImpl conf = new JDBCConfigurationImpl();
        cp.setInto(conf);
        return new JDBCBrokerFactory(conf);
}

Factory method for constructing a factory from properties. Invoked from Bootstrap#newBrokerFactory .

 protected StoreManager newStoreManager() 
{
        return new JDBCStoreManager();
}

 protected  void synchronizeMappings(ClassLoader loader) 
{
        JDBCConfiguration conf = (JDBCConfiguration) getConfiguration();
        String action = conf.getSynchronizeMappings();
        if (StringUtils.isEmpty(action))
            return;
        MappingRepository repo = conf.getMappingRepositoryInstance();
        Collection classes = repo.loadPersistentTypes(false, loader);
        if (classes.isEmpty())
            return;
        String props = Configurations.getProperties(action);
        action = Configurations.getClassName(action);
        MappingTool tool = new MappingTool(conf, action, false);
        Configurations.configureInstance(tool, conf, props,
            "SynchronizeMappings");
        // initialize the schema
        Class cls;
        for (Iterator itr = classes.iterator(); itr.hasNext();) {
            cls = (Class) itr.next();
            try {
                tool.run(cls);
            } catch (IllegalArgumentException iae) {
                throw new UserException(_loc.get("bad-synch-mappings",
                    action, Arrays.asList(MappingTool.ACTIONS)));
            }
        }
        tool.record();
}

Synchronize the mappings of the classes listed in the configuration.