public AnnotationFields(DeployBeanInfo<?> info) {
super(info);
if (GlobalProperties.getBoolean("ebean.lobEagerFetch", false)) {
defaultLobFetchType = FetchType.EAGER;
}
}
public DLoadContext(
SpiEbeanServer ebeanServer,
BeanDescriptor<?> rootDescriptor,
Boolean readOnly,
boolean excludeBeanCache,
ObjectGraphNode parentNode,
boolean useAutofetchManager) {
this.ebeanServer = ebeanServer;
this.hardRefs = GlobalProperties.getBoolean("ebean.hardrefs", false);
this.defaultBatchSize = ebeanServer.getLazyLoadBatchSize();
this.rootDescriptor = rootDescriptor;
this.rootBeanContext =
new DLoadBeanContext(
this, rootDescriptor, null, defaultBatchSize, null, createBeanLoadList());
this.readOnly = readOnly;
this.excludeBeanCache = excludeBeanCache;
this.useAutofetchManager = useAutofetchManager;
if (parentNode != null) {
this.origin = parentNode.getOriginQueryPoint();
this.relativePath = parentNode.getPath();
} else {
this.origin = null;
this.relativePath = null;
}
}
private SpiBackgroundExecutor createBackgroundExecutor(
ServerConfig serverConfig, int uniqueServerId) {
String namePrefix = "Ebean-" + serverConfig.getName();
// the size of the pool for executing periodic tasks (such as cache
// flushing)
int schedulePoolSize = GlobalProperties.getInt("backgroundExecutor.schedulePoolsize", 1);
// the side of the main pool for immediate background task execution
int minPoolSize = GlobalProperties.getInt("backgroundExecutor.minPoolSize", 1);
int poolSize = GlobalProperties.getInt("backgroundExecutor.poolsize", 20);
int maxPoolSize = GlobalProperties.getInt("backgroundExecutor.maxPoolSize", poolSize);
int idleSecs = GlobalProperties.getInt("backgroundExecutor.idlesecs", 60);
int shutdownSecs = GlobalProperties.getInt("backgroundExecutor.shutdownSecs", 30);
boolean useTrad = GlobalProperties.getBoolean("backgroundExecutor.traditional", true);
if (useTrad) {
// this pool will use Idle seconds between min and max so I think it is
// better
// as it will let the thread count float between the min and max
ThreadPool pool = ThreadPoolManager.getThreadPool(namePrefix);
pool.setMinSize(minPoolSize);
pool.setMaxSize(maxPoolSize);
pool.setMaxIdleTime(idleSecs * 1000);
return new TraditionalBackgroundExecutor(pool, schedulePoolSize, shutdownSecs, namePrefix);
} else {
return new DefaultBackgroundExecutor(
poolSize, schedulePoolSize, idleSecs, shutdownSecs, namePrefix);
}
}
public DefaultServerFactory() {
this.clusterManager = new ClusterManager();
this.jndiDataSourceFactory = new JndiDataSourceLookup();
List<String> packages =
getSearchJarsPackages(GlobalProperties.get("ebean.search.packages", null));
List<String> jars = getSearchJarsPackages(GlobalProperties.get("ebean.search.jars", null));
this.bootupClassSearch = new BootupClassPathSearch(null, packages, jars);
this.xmlConfigLoader = new XmlConfigLoader(null);
this.xmlConfig = xmlConfigLoader.load();
// register so that we can shutdown any Ebean wide
// resources such as clustering
ShutdownManager.registerServerFactory(this);
}
/** Create and return the CacheManager. */
private ServerCacheManager getCacheManager(ServerConfig serverConfig) {
ServerCacheManager serverCacheManager = serverConfig.getServerCacheManager();
if (serverCacheManager != null) {
return serverCacheManager;
}
// reasonable default settings are for a cache per bean type
ServerCacheOptions beanOptions = new ServerCacheOptions();
beanOptions.setMaxSize(GlobalProperties.getInt("cache.maxSize", 1000));
// maxIdleTime 10 minutes
beanOptions.setMaxIdleSecs(GlobalProperties.getInt("cache.maxIdleTime", 60 * 10));
// maxTimeToLive 6 hrs
beanOptions.setMaxSecsToLive(GlobalProperties.getInt("cache.maxTimeToLive", 60 * 60 * 6));
// reasonable default settings for the query cache per bean type
ServerCacheOptions queryOptions = new ServerCacheOptions();
queryOptions.setMaxSize(GlobalProperties.getInt("querycache.maxSize", 100));
// maxIdleTime 10 minutes
queryOptions.setMaxIdleSecs(GlobalProperties.getInt("querycache.maxIdleTime", 60 * 10));
// maxTimeToLive 6 hours
queryOptions.setMaxSecsToLive(GlobalProperties.getInt("querycache.maxTimeToLive", 60 * 60 * 6));
ServerCacheFactory cacheFactory = serverConfig.getServerCacheFactory();
if (cacheFactory == null) {
cacheFactory = new DefaultServerCacheFactory();
}
return new DefaultServerCacheManager(cacheFactory, beanOptions, queryOptions);
}
/** Create using the ServerConfig object to configure the server. */
public static EbeanServer create(ServerConfig config) {
if (config.getName() == null) {
throw new PersistenceException("The name is null (it is required)");
}
EbeanServer server = serverFactory.createServer(config);
if (config.isDefaultServer()) {
GlobalProperties.setSkipPrimaryServer(true);
}
if (config.isRegister()) {
Ebean.register(server, config.isDefaultServer());
}
return server;
}
/** Create the implementation from the configuration. */
public SpiEbeanServer createServer(ServerConfig serverConfig) {
synchronized (this) {
setNamingConvention(serverConfig);
BootupClasses bootupClasses = getBootupClasses(serverConfig);
setDataSource(serverConfig);
// check the autoCommit and Transaction Isolation
boolean online = checkDataSource(serverConfig);
// determine database platform (Oracle etc)
setDatabasePlatform(serverConfig);
if (serverConfig.getDbEncrypt() != null) {
// use a configured DbEncrypt rather than the platform default
serverConfig.getDatabasePlatform().setDbEncrypt(serverConfig.getDbEncrypt());
}
DatabasePlatform dbPlatform = serverConfig.getDatabasePlatform();
PstmtBatch pstmtBatch = null;
if (dbPlatform.getName().startsWith("oracle")) {
PstmtDelegate pstmtDelegate = serverConfig.getPstmtDelegate();
if (pstmtDelegate == null) {
// try to provide the
pstmtDelegate = getOraclePstmtDelegate(serverConfig.getDataSource());
}
if (pstmtDelegate != null) {
// We can support JDBC batching with Oracle
// via OraclePreparedStatement
pstmtBatch = new OraclePstmtBatch(pstmtDelegate);
}
if (pstmtBatch == null) {
// We can not support JDBC batching with Oracle
logger.warning("Can not support JDBC batching with Oracle without a PstmtDelegate");
serverConfig.setPersistBatching(false);
}
}
// inform the NamingConvention of the associated DatabasePlaform
serverConfig.getNamingConvention().setDatabasePlatform(serverConfig.getDatabasePlatform());
ServerCacheManager cacheManager = getCacheManager(serverConfig);
int uniqueServerId = serverId.incrementAndGet();
SpiBackgroundExecutor bgExecutor = createBackgroundExecutor(serverConfig, uniqueServerId);
InternalConfiguration c =
new InternalConfiguration(
xmlConfig,
clusterManager,
cacheManager,
bgExecutor,
serverConfig,
bootupClasses,
pstmtBatch);
DefaultServer server = new DefaultServer(c, cacheManager);
cacheManager.init(server);
MBeanServer mbeanServer;
ArrayList<?> list = MBeanServerFactory.findMBeanServer(null);
if (list.size() == 0) {
// probably not running in a server
mbeanServer = MBeanServerFactory.createMBeanServer();
} else {
// use the first MBeanServer
mbeanServer = (MBeanServer) list.get(0);
}
server.registerMBeans(mbeanServer, uniqueServerId);
// generate and run DDL if required
executeDDL(server, online);
// initialise prior to registering with clusterManager
server.initialise();
if (online) {
if (clusterManager.isClustering()) {
// register the server once it has been created
clusterManager.registerServer(server);
}
// warm the cache in 30 seconds
int delaySecs = GlobalProperties.getInt("ebean.cacheWarmingDelay", 30);
long sleepMillis = 1000 * delaySecs;
if (sleepMillis > 0) {
Timer t = new Timer("EbeanCacheWarmer", true);
t.schedule(new CacheWarmer(server), sleepMillis);
}
}
// start any services after registering with clusterManager
server.start();
return server;
}
}