Java 类org.springframework.context.ApplicationContext 实例源码

@Bean
public Server jettyServer(ApplicationContext context) throws Exception {
    HttpHandler handler = WebHttpHandlerBuilder.applicationContext(context).build();
    Servlet servlet = new JettyHttpHandlerAdapter(handler);

    Server server = new Server();
    ServletContextHandler contextHandler = new ServletContextHandler(server, "");
    contextHandler.addServlet(new ServletHolder(servlet), "/");
    contextHandler.start();

    ServerConnector connector = new ServerConnector(server);
    connector.setHost("localhost");
    connector.setPort(port);
    server.addConnector(connector);

    return server;
}

@Test
public void Test4(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//��ʼ������
    BuildingDealDao buildingDealDao = (BuildingDealDao) ac.getBean("buildingDealDao");
    BuildingDeal u = new BuildingDeal();
    u.setAgentId(2);
    u.setBuildingDealPerPrice(100);
    u.setBuildingDealTime(new Date());
    u.setBuildingDealTotalPrice(100);
    u.setBuildingId(1);
    u.setBuildingLayout("111��һ��");
    u.setUserId(1);
    u.setBuildingDealId(1);
    buildingDealDao.deleteBuildingDeal(u);
    System.out.println(u.getBuildingLayout());
}

@Override
public final void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {
    this.applicationContext = applicationContext;

    try {
        logger.info("Initializing {} root application context", contextInitializerName);
        initializeRootApplicationContext();
        logger.info("Initialized {} root application context successfully", contextInitializerName);

        logger.info("Initializing {} servlet application context", contextInitializerName);
        initializeServletApplicationContext();
        logger.info("Initialized {} servlet application context successfully", contextInitializerName);
    } catch (final Exception e) {
        logger.error(e.getMessage(), e);
    }
}

@SuppressWarnings("unchecked")
@Before
public void mockApplicationContext() {
    final ApplicationContext applicationContext = Mockito.mock(ApplicationContext.class);
    SpringUtils.setSharedApplicationContext(applicationContext);
    mockLdapResource = Mockito.mock(UserOrgResource.class);
    final UserFullLdapTask mockTask = new UserFullLdapTask();
    mockTask.resource = mockLdapResource;
    mockTask.securityHelper = securityHelper;
    final UserAtomicLdapTask mockTaskUpdate = new UserAtomicLdapTask();
    mockTaskUpdate.resource = mockLdapResource;
    mockTaskUpdate.securityHelper = securityHelper;
    Mockito.when(applicationContext.getBean(SessionSettings.class)).thenReturn(new SessionSettings());
    Mockito.when(applicationContext.getBean((Class<?>) ArgumentMatchers.any(Class.class))).thenAnswer((Answer<Object>) invocation -> {
        final Class<?> requiredType = (Class<Object>) invocation.getArguments()[0];
        if (requiredType == UserFullLdapTask.class) {
            return mockTask;
        }
        if (requiredType == UserAtomicLdapTask.class) {
            return mockTaskUpdate;
        }
        return UserBatchLdapResourceTest.super.applicationContext.getBean(requiredType);
    });

    mockTaskUpdate.jaxrsFactory = ServerProviderFactory.createInstance(null);
}

@Override protected void after()
{
    // Set up required services
    ApplicationContext ctxt = getApplicationContext();
    final RetryingTransactionHelper transactionHelper = (RetryingTransactionHelper) ctxt.getBean("retryingTransactionHelper");

    transactionHelper.doInTransaction(new RetryingTransactionCallback<Void>()
    {
        @Override public Void execute() throws Throwable
        {
            for (Map.Entry<String, NodeRef> entry : usersPersons.entrySet())
            {
                deletePerson(entry.getKey());
            }

            return null;
        }
    });
}

public static void main(String[] args) {

        ApplicationContext ctx =  SpringApplication.run(LearnspringdiApplication.class, args);

        //Always the bean name will be equivalent to the class name (but starts with lowercase)
        FirstController controller = (FirstController) ctx.getBean("firstController");
        System.out.println(controller.sayHello());
        System.out.println(ctx.getBean(PropertyInjectController.class).sayHello());
        System.out.println(ctx.getBean(SetterInjectController.class).sayHello());
        System.out.println(ctx.getBean(ConstructorInjectController.class).sayHello());

        TestDataSource testDataSource = (TestDataSource) ctx.getBean(TestDataSource.class);
        System.out.println("Reading value from external Property File :"+ testDataSource.getDbUrl());

        TestEnvProp testEnvProp = (TestEnvProp) ctx.getBean(TestEnvProp.class);
        System.out.println("Accessed System value through Spring Environmet Variable "+testEnvProp.getSystemUserName());
        System.out.println("Accessed System value directly via Spring @Value Annotation :"+testEnvProp.JAVA_VERSION);

        TestJmsBroker testJmsBroker = (TestJmsBroker) ctx.getBean(TestJmsBroker.class);
        System.out.println("Accessed multiple property file values using @PropertySources :"+testJmsBroker.getJmsUrl());
    }

@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    try {
        repository = repositoryBuilder.getRepository();
        SimpleCredentials cred = new SimpleCredentials("admin", "admin".toCharArray());
        cred.setAttribute("AutoRefresh", true);
        session = repository.login(cred, null);
        versionManager = session.getWorkspace().getVersionManager();
        lockManager=session.getWorkspace().getLockManager();
        Collection<RepositoryInteceptor> repositoryInteceptors=applicationContext.getBeansOfType(RepositoryInteceptor.class).values();
        if(repositoryInteceptors.size()==0){
            repositoryInteceptor=new DefaultRepositoryInteceptor();
        }else{
            repositoryInteceptor=repositoryInteceptors.iterator().next();
        }
    } catch (Exception ex) {
        throw new RuleException(ex);
    }
}

@Override
public void release() {
    if (this.applicationContext != null) {
        ApplicationContext savedCtx;

        // We don't actually guarantee thread-safety, but it's not a lot of extra work.
        synchronized (this) {
            savedCtx = this.applicationContext;
            this.applicationContext = null;
        }

        if (savedCtx != null && savedCtx instanceof ConfigurableApplicationContext) {
            ((ConfigurableApplicationContext) savedCtx).close();
        }
    }
}

@Test
public void Test2(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");//��ʼ������
    BuildingLayoutDao buildingLayoutDao = (BuildingLayoutDao) ac.getBean("buildingLayoutDao");
    BuildingLayout u = new BuildingLayout();

    u.setBuildingId(2);
    u.setBuildingLayout("һ��һ��");
    u.setBuildingLayoutPerPrice(2);
    u.setBuildingLayoutPicUrl("2112512");
    u.setBuildingLayoutReferencePrice(2);
    u.setBuildingLayoutSoldOut(2);

    buildingLayoutDao.updateBuildingLayout(u);

    System.out.println("-------");
}

@Override
public void refresh(ApplicationContext applicationContext)
{
    unResolvePostProcessList = new ArrayList<>();

    Map<String, UnResolvePostProcess> unResolvePostProcessMap = applicationContext.getBeansOfType(UnResolvePostProcess.class);

    if (!CollectionUtils.isEmpty(unResolvePostProcessMap)) {
        unResolvePostProcessList.addAll(unResolvePostProcessMap.values());
    }
    unResolvePostProcessMap = null;

    unResolveFieldPostProcessList = new ArrayList<>();

    Map<String, UnResolveFieldPostProcess> unResolveFieldPostProcessMap = applicationContext.getBeansOfType(UnResolveFieldPostProcess.class);

    if (!CollectionUtils.isEmpty(unResolveFieldPostProcessMap)) {
        unResolveFieldPostProcessList.addAll(unResolveFieldPostProcessMap.values());
    }
    unResolveFieldPostProcessMap = null;

}

public static void main(String[] args) throws Exception {
    ApplicationContext context = new AnnotationConfigApplicationContext(Application.class);  // (1)

    Tomcat tomcatServer = context.getBean(Tomcat.class);
    tomcatServer.start();

    System.out.println("Press ENTER to exit.");
    System.in.read();
}

@Test
public void select() {
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    RentHousePicDao dao = (RentHousePicDao) ac.getBean("rentHousePicDao");
    RentHousePic c = new RentHousePic();
    c.setRentHousePicId(2);
    System.out.println(dao.selectRentHousePic(c).getPicUrl());
}

@Test
public void test(){
    ApplicationContext atc=new AnnotationConfigApplicationContext(SystemXml.class);
    SystemXmlMap map=(SystemXmlMap)atc.getBean("systemXmlMap");
    PrinterUtils.printILog(map.toString());

    Environment environment=(Environment)atc.getBean("environment");
    PrinterUtils.printILog(environment.getProperty("username"));
}

@Bean(name="serverBrowse")
public NettyContext nettyContext(ApplicationContext context) {
    HttpHandler handler = DispatcherHandler.toHttpHandler(context);
    ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(handler);
    HttpServer httpServer = HttpServer.create(host, port);
    return httpServer.newHandler(adapter).block();
}

@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    XxlJobDynamicScheduler.xxlJobLogDao = applicationContext.getBean(IXxlJobLogDao.class);
    XxlJobDynamicScheduler.xxlJobInfoDao = applicationContext.getBean(IXxlJobInfoDao.class);
       XxlJobDynamicScheduler.xxlJobRegistryDao = applicationContext.getBean(IXxlJobRegistryDao.class);
       XxlJobDynamicScheduler.xxlJobGroupDao = applicationContext.getBean(IXxlJobGroupDao.class);
}

@Test
public void should_detect_duplicated_beans_of_the_same_type_on_the_same_level() {
    //given
    class Bean {}
    final ApplicationContext ctx = buildAppContext(Stream.of(
            bean("1", new Bean()),
            bean("2", new Bean())));
    final ApplicationContextWalker walker = new ApplicationContextWalker(ctx);

    //expect
    assertFalse(walker.hasOnlyOneBeanOfClass(Bean.class));
}

private Properties loadConfigLocationProperties(ApplicationContext applicationContext, 
        QuartzSchedulerProperties properties) throws IOException {

    String location = properties.getPropertiesConfigLocation();
    if(null == location || location.trim().length() == 0) {
        location = QuartzSchedulerProperties.DEFAULT_CONFIG_LOCATION;
        LOGGER.debug("using default 'quartz.properties' from classpath: " + location);
    } else {
        LOGGER.debug("using 'quartz.properties' from location: " + location);
    }
    PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
    propertiesFactoryBean.setLocation(applicationContext.getResource(location));
    propertiesFactoryBean.afterPropertiesSet();
    return propertiesFactoryBean.getObject();
}

@Override
protected void setUp() throws Exception
{
    super.setUp();
    ApplicationContext appContext = getServer().getApplicationContext();

    nodeService = (NodeService)appContext.getBean("NodeService");
    replicationService = (ReplicationService)appContext.getBean("ReplicationService");
    actionTrackingService = (ActionTrackingService)appContext.getBean("actionTrackingService");
    repositoryHelper = (Repository)appContext.getBean("repositoryHelper");
    transactionService = (TransactionService)appContext.getBean("transactionService");

    MutableAuthenticationService authenticationService = (MutableAuthenticationService)appContext.getBean("AuthenticationService");
    PersonService personService = (PersonService)appContext.getBean("PersonService");
    personManager = new TestPersonManager(authenticationService, personService, nodeService);

    UserTransaction txn = transactionService.getUserTransaction();
    txn.begin();

    personManager.createPerson(USER_NORMAL);

    // Ensure we start with no replication definitions
    // (eg another test left them behind)
    AuthenticationUtil.setFullyAuthenticatedUser(AuthenticationUtil.getAdminUserName());
    for(ReplicationDefinition rd : replicationService.loadReplicationDefinitions()) {
       replicationService.deleteReplicationDefinition(rd);
    }
    txn.commit();

    // Grab a reference to the data dictionary
    dataDictionary = nodeService.getChildByName(
             repositoryHelper.getCompanyHome(),
             ContentModel.ASSOC_CONTAINS,
             "Data Dictionary"
    );

    AuthenticationUtil.clearCurrentSecurityContext();
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    ApplicationContext context=new ClassPathXmlApplicationContext("customer.xml");
    Customer customer=(Customer)context.getBean("customer");
    System.out.println(customer.getCust_name()+"\t"+customer.getCust_id());
       System.out.println(customer.getCust_address());   
}

@Test
public void resetPasswordByAdmin() {
    resource.applicationContext = Mockito.mock(ApplicationContext.class);
    final IPasswordGenerator generator = Mockito.mock(IPasswordGenerator.class);
    Mockito.when(resource.applicationContext.getBeansOfType(IPasswordGenerator.class)).thenReturn(Collections.singletonMap("bean", generator));
    resource.resetPasswordByAdmin(newUser());
    Mockito.verify(generator, VerificationModeFactory.atLeast(1)).generate("wuser");
}

@Bean
public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
    return args -> {

        System.out.println("Let's inspect the beans provided by Spring Boot:\n");

        String[] beanNames = ctx.getBeanDefinitionNames();
        Arrays.sort(beanNames);
        for (String beanName : beanNames) {
            System.out.println(beanName);
        }

        System.out.println("---");
    };
}

@Autowired
SpringDeploymentManager(
        final ApplicationContext context,
        final VerticleFactory verticleFactory,
        final Vertx vertx,
        @Value("${thread.pool.size}") final int threadPoolSize
) {
    this.context = context;
    this.verticleFactory = verticleFactory;
    this.vertx = vertx;
    this.threadPoolSize = getThreadPoolSize(threadPoolSize);
}

private Map<String, Object> getConfigurationPropertiesBeans(
        ApplicationContext context,
        ConfigurationBeanFactoryMetaData beanFactoryMetaData) {
    Map<String, Object> beans = new LinkedHashMap<String, Object>();
    beans.putAll(context.getBeansWithAnnotation(ConfigurationProperties.class));
    if (beanFactoryMetaData != null) {
        beans.putAll(beanFactoryMetaData
                .getBeansWithFactoryAnnotation(ConfigurationProperties.class));
    }
    return beans;
}

/**
 * Return the current application context as WebApplicationContext.
 * <p><b>NOTE:</b> Only use this if you actually need to access
 * WebApplicationContext-specific functionality. Preferably use
 * {@code getApplicationContext()} or {@code getServletContext()}
 * else, to be able to run in non-WebApplicationContext environments as well.
 * @throws IllegalStateException if not running in a WebApplicationContext
 * @see #getApplicationContext()
 */
protected final WebApplicationContext getWebApplicationContext() throws IllegalStateException {
    ApplicationContext ctx = getApplicationContext();
    if (ctx instanceof WebApplicationContext) {
        return (WebApplicationContext) getApplicationContext();
    }
    else if (isContextRequired()) {
        throw new IllegalStateException("WebApplicationObjectSupport instance [" + this +
                "] does not run in a WebApplicationContext but in: " + ctx);
    }
    else {
        return null;
    }
}

public void mockBeanUtils() {

    new MockUp<BeanUtils>() {
      @Mock
      ApplicationContext getContext() {
        return Mockito.mock(ApplicationContext.class);
      }
    };
  }

@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    if(applicationContext instanceof WebApplicationContext){
        WebApplicationContext context=(WebApplicationContext)applicationContext;
        baseWebPath=context.getServletContext().getRealPath("/");
    }
    this.applicationContext=applicationContext;
}

public static void main(String[] args)
{

    // initialise app content 
    ApplicationContext ctx = ApplicationContextHelper.getApplicationContext();
    // get registry of services
    final ServiceRegistry serviceRegistry = (ServiceRegistry) ctx.getBean(ServiceRegistry.SERVICE_REGISTRY);

    // authenticate
    AuthenticationService authenticationService = serviceRegistry.getAuthenticationService();
    authenticationService.authenticate(AuthenticationUtil.getAdminUserName(), "admin".toCharArray());


    // use TransactionWork to wrap service calls in a user transaction
    TransactionService transactionService = serviceRegistry.getTransactionService();
    RetryingTransactionCallback<Object> exampleWork = new RetryingTransactionCallback<Object>()
    {
        public Object execute() throws Exception
        {
            doExample(serviceRegistry);
            return null;
        }
    };
    currentDoc = 0;
    while (currentDoc < totalNumDocs)
    {
        transactionService.getRetryingTransactionHelper().doInTransaction(exampleWork);
    }
    System.exit(0);
}

@Autowired
public void setApplicationContext(ApplicationContext ctx) {
    if (!DefaultListableBeanFactory.class.isAssignableFrom(ctx.getAutowireCapableBeanFactory().getClass())) {
        throw new IllegalArgumentException("BeanFactory must be DefaultListableBeanFactory type");
    }
    this.ctx = ctx;
    this.beanFactory = (DefaultListableBeanFactory) ctx.getAutowireCapableBeanFactory();
}

@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    Collection<KnowledgeCache> caches=applicationContext.getBeansOfType(KnowledgeCache.class).values();
    if(caches.size()>0){
        CacheUtils.knowledgeCache=caches.iterator().next();
    }else{
        CacheUtils.knowledgeCache=new MemoryKnowledgeCache();
    }
}

public static void main(String[] args) {
    ApplicationContext applicationContext = 
            SpringApplication.run(SpringbootIn10StepsApplication.class, args);

    for (String name : applicationContext.getBeanDefinitionNames()) {
        System.out.println(name);
    }
}

/**
 * Main method, used to run the application.
 *
 * @param args the command line arguments
 * @throws UnknownHostException if the local host name could not be resolved into an address
 */
public static void main(String[] args) throws Exception {
    SpringApplication app = new SpringApplication(AlbedoThriftExampleClient.class);
    final ApplicationContext applicationContext = app.run(args);
    Environment env = applicationContext.getEnvironment();
    log.info("\n----------------------------------------------------------\n\t" +
                    "Application '{}' is running! ",
            env.getProperty("spring.application.name"));
}

/**
 * 实现ApplicationContextAware接口, 注入Context到静态变量中.
 */
public void setApplicationContext(ApplicationContext applicationContext) {
    logger.debug("set applicationContext to springContextHolder:" + applicationContext);
    if (SpringContextHelper.applicationContext != null) {
        logger.warn("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHelper.applicationContext);
    }
    SpringContextHelper.applicationContext = applicationContext; // NOSONAR
}

public static void main(String[] args) throws InterruptedException {

        ApplicationContext app = SpringApplication.run(Application.class, args);

        while (true) {
            Sender sender = app.getBean(Sender.class);
            sender.sendMessage();
            Thread.sleep(5000);
        }
    }

@Profile("default")
@Bean
public NettyContext nettyContext(ApplicationContext context) {
    HttpHandler handler = WebHttpHandlerBuilder.applicationContext(context).build();
    ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(handler);
    HttpServer httpServer = HttpServer.create("localhost", this.port);
    return httpServer.newHandler(adapter).block();
}

@Before
public void init(){
    @SuppressWarnings("resource")
    ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    SqlSessionFactory sqlSessionFactory =  context.getBean(SqlSessionFactory.class);
    sqlMapper = new SqlMapperTemplate(sqlSessionFactory);
}

@Bean
public  NettyContext nettyContext(ApplicationContext context) {
    HttpHandler handler = DispatcherHandler.toHttpHandler(context);
    ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(handler);
    HttpServer httpServer = HttpServer.create("localhost", Integer.valueOf("9008"));
    return httpServer.newHandler(adapter).block();
}

static Object resolveDependency(Parameter parameter, Class<?> containingClass, ApplicationContext applicationContext) {
    boolean required = findMergedAnnotation(parameter, Autowired.class).map(Autowired::required).orElse(true);
    MethodParameter methodParameter = SynthesizingMethodParameter.forParameter(parameter);
    DependencyDescriptor descriptor = new DependencyDescriptor(methodParameter, required);
    descriptor.setContainingClass(containingClass);
    return applicationContext.getAutowireCapableBeanFactory().resolveDependency(descriptor, null);
}

private String getI18nMessage(Connection conn) throws MigrationException {
// get spring bean
ApplicationContext context = new ClassPathXmlApplicationContext("org/lamsfoundation/lams/messageContext.xml");
MessageService messageService = (MessageService) context.getBean("commonMessageService");

// get server locale
String defaultLocale = "en_AU";
String getDefaultLocaleStmt = "select config_value from lams_configuration where config_key='ServerLanguage'";
try {
    PreparedStatement query = conn.prepareStatement(getDefaultLocaleStmt);
    ResultSet results = query.executeQuery();
    while (results.next()) {
    defaultLocale = results.getString("config_value");
    }
} catch (Exception e) {
    throw new MigrationException("Problem running update; ", e);
}

String[] tokenisedLocale = defaultLocale.split("_");
Locale locale = new Locale(tokenisedLocale[0], tokenisedLocale[1]);

// get i18n'd message for text 'run sequences'
MessageSource messageSource = messageService.getMessageSource();
String i18nMessage = messageSource.getMessage("runsequences.folder.name", new Object[] { "" }, locale);

if (i18nMessage != null && i18nMessage.startsWith("???")) {
    // default to English if not present
    return " Run Sequences";
}
return i18nMessage;
   }

@Bean
public  NettyContext nettyContext(ApplicationContext context) {
    HttpHandler handler = DispatcherHandler.toHttpHandler(context);
    ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(handler);
    HttpServer httpServer = HttpServer.create("localhost", Integer.valueOf("8908"));
    return httpServer.newHandler(adapter).block();
}