Java Code Examples for org.springframework.beans.factory.annotation.Autowired

/** 
 * BeanDefinitionRegistryPostProcessor's method second run: check which spring bean that need injected from Jdon.
 */
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
  for (  String beanName : registry.getBeanDefinitionNames()) {
    BeanDefinition beanDefinition=registry.getBeanDefinition(beanName);
    String beanClassName=beanDefinition.getBeanClassName();
    try {
      Class beanClass=Class.forName(beanClassName);
      for (      final Field field : ClassUtil.getAllDecaredFields(beanClass)) {
        if (field.isAnnotationPresent(Autowired.class)) {
          Object o=findBeanClassInJdon(field.getType());
          if (o != null) {
            neededJdonComponents.put(field.getName(),o);
          }
        }
      }
    }
 catch (    ClassNotFoundException ex) {
      ex.printStackTrace();
    }
  }
}
 

@Autowired public void setGraphService(GraphService graphService){
  Graph graph=graphService.getGraph();
  if (graph == null)   return;
  pedestrianIndex=new STRtree();
  index=new STRtree();
  for (  StreetVertex vertex : IterableLibrary.filter(graph.getVertices(),StreetVertex.class)) {
    for (    StreetEdge e : IterableLibrary.filter(vertex.getOutgoing(),StreetEdge.class)) {
      Geometry geom=e.getGeometry();
      if (e.getPermission().allows(StreetTraversalPermission.PEDESTRIAN)) {
        pedestrianIndex.insert(geom.getEnvelopeInternal(),e);
      }
      index.insert(geom.getEnvelopeInternal(),e);
    }
  }
  pedestrianIndex.build();
  index.build();
  LOG.debug("spatial index size: {}",pedestrianIndex.size());
}
 

@Autowired(required=false) void setupScheduledTaskRegistrar(Collection<ScheduledConfigurationCustomizer> listeners){
  if (listeners != null && !listeners.isEmpty()) {
    ScheduledConfigurationCustomizerComposite delegate=new ScheduledConfigurationCustomizerComposite();
    delegate.registerListeners(listeners);
    registrar=new ScheduledTaskRegistrar();
    Object scheduler=getScheduler();
    if (scheduler != null) {
      registrar.setScheduler(scheduler);
    }
    try {
      delegate.configureTasks(registrar);
    }
 catch (    Exception e) {
      throw new BeanDefinitionStoreException("Could not customize task scheduler",e);
    }
  }
}
 

/** 
 * @param availableWebBaseUrl the availableWebBaseUrl to set
 */
@Autowired public void setAvailableWebBaseUrl(String availableWebBaseUrl){
  Validate.notEmpty(availableWebBaseUrl,"availableWebBaseUrl property must not be empty");
  this.availableWebBaseUrl=availableWebBaseUrl;
  if (!this.availableWebBaseUrl.endsWith("/")) {
    this.availableWebBaseUrl+="/";
  }
  this.advisorUrl=this.availableWebBaseUrl + "public/advisors.html";
  this.profileSearchUrl=this.availableWebBaseUrl + "public/index.html";
}
 

@Autowired public DBInit(CommandBus commandBus,@Qualifier("mongoTemplate") CFMongoTemplate systemMongo,MongoEventStore eventStore,CFMongoTemplate mongoTemplate,MongoTemplate systemAxonSagaMongo){
  this.commandBus=commandBus;
  systemAxonMongo=systemMongo;
  this.eventStore=eventStore;
  this.mongoTemplate=mongoTemplate;
  this.systemAxonSagaMongo=systemAxonSagaMongo;
}
 

@Test public void injectionUsingConstrettoWithEnvironmentSetAndUsinginterface(){
class MyConsumer {
    @Autowired CommonInterface commonInterface;
  }
  setProperty(ASSEMBLY_KEY,"stub");
  ApplicationContext ctx=loadContextAndInjectWithConstretto();
  MyConsumer consumer=new MyConsumer();
  ctx.getAutowireCapableBeanFactory().autowireBean(consumer);
  Assert.assertEquals(consumer.commonInterface.getClass(),CommonInterfaceStub.class);
}
 

@Autowired public ExperimentDataService(ExperimentSolrDAO experimentSolrDAO,AtlasDAO atlasDAO,AtlasDataDAO atlasDataDAO,GeneSolrDAO geneSolrDAO,AtlasExperimentAnalyticsViewService expAnalyticsService){
  this.experimentSolrDAO=experimentSolrDAO;
  this.atlasDAO=atlasDAO;
  this.atlasDataDAO=atlasDataDAO;
  this.geneSolrDAO=geneSolrDAO;
  this.expAnalyticsService=expAnalyticsService;
}
 

@Autowired public void setSeeds(SeedModule seeds){
  this.seeds=seeds;
  if (seeds != null) {
    seeds.addSeedListener(this);
  }
}
 

@Autowired public void setDataSource(DataSource dataSource) throws Exception {
  dao=new JdbcSearchableStepExecutionDao();
  dao.setDataSource(dataSource);
  dao.afterPropertiesSet();
  jobExecutionDao=new JdbcSearchableJobExecutionDao();
  jobExecutionDao.setDataSource(dataSource);
  jobExecutionDao.afterPropertiesSet();
}
 

@Autowired public MovieController(CineastsRepository cineastsRepository,DatabasePopulator populator,CineastsUserDetailsService userDetailsService,Neo4jTemplate template){
  this.cineastsRepository=cineastsRepository;
  this.populator=populator;
  this.userDetailsService=userDetailsService;
  this.template=template;
}
 

@Autowired public CustomArgumentController(RequestMappingHandlerAdapter controllerInvoker){
  WebArgumentResolver argResolver=new WebArgumentResolver(){
    public Object resolveArgument(    MethodParameter param,    NativeWebRequest request) throws Exception {
      RequestAttribute attr=param.getParameterAnnotation(RequestAttribute.class);
      if (attr != null) {
        return request.getAttribute(attr.value(),WebRequest.SCOPE_REQUEST);
      }
 else {
        return WebArgumentResolver.UNRESOLVED;
      }
    }
  }
;
  List<HandlerMethodArgumentResolver> resolvers=new ArrayList<HandlerMethodArgumentResolver>();
  resolvers.add(new ServletWebArgumentResolverAdapter(argResolver));
  controllerInvoker.setCustomArgumentResolvers(resolvers);
}
 

@Autowired public ConstructorValueTestBean(@Value("XXX#{tb0.name}YYY#{mySpecialAttr}ZZZ") String name,@Value("#{mySpecialAttr}") int age,@Qualifier("original") TestBean tb,@Value("${code} #{systemProperties.country}") String country){
  this.name=name;
  this.age=age;
  this.country=country;
  this.tb=tb;
}
 

@Autowired public JdbcMailUserService(JdbcTemplate jdbcTemplate){
  if (jdbcTemplate == null) {
    throw new IllegalArgumentException("jdbcTemplate cannot be null");
  }
  this.jdbcTemplate=jdbcTemplate;
}
 

/** 
 * Sets the handlers.
 * @param newHandlers the new handlers
 */
@Autowired(required=false) public void setHandlers(List<EventHandler> newHandlers){
  this.handlers.clear();
  for (  EventHandler eventHandler : newHandlers) {
    this.handlers.add(eventHandler);
  }
}
 

@Autowired public void setProperties(Properties properties){
  this.properties=properties;
  if (properties != null) {
    maxPersistenceTokenAge=getExpirationProperty("persistence",maxPersistenceTokenAge);
    setExpirationFromProperties("access");
    setExpirationFromProperties("refresh");
    setExpirationFromProperties("email");
    setExpirationFromProperties("offline");
    tokenSecretSalt=properties.getProperty(PROPERTIES_AUTH_TOKEN_SECRET_SALT,TOKEN_SECRET_SALT);
  }
}
 

@Autowired public RulesController(HibernateRuleDao ruleDao,AutoFormatView view){
  this.ruleDao=ruleDao;
  this.view=view;
  String[] methods={"GET","PUT","DELETE","POST"};
  this.setSupportedMethods(methods);
}
 

/** 
 * Creates a new  {@link AccountServiceImpl}.
 * @param repository must not be {@literal null}.
 */
@Autowired public AccountServiceImpl(AccountRepository accountRepository,CustomerRepository customerRepository){
  Assert.notNull(accountRepository);
  Assert.notNull(customerRepository);
  this.accountRepository=accountRepository;
  this.customerRepository=customerRepository;
}
 

@SuppressWarnings("SpringJavaAutowiringInspection") @Autowired public CompanyController(CompanyQueryRepository companyRepository,CommandBus commandBus,UserQueryRepository userRepository,OrderBookQueryRepository orderBookRepository,TradeExecutedQueryRepository tradeExecutedRepository,PortfolioQueryRepository portfolioQueryRepository){
  this.companyRepository=companyRepository;
  this.commandBus=commandBus;
  this.userRepository=userRepository;
  this.orderBookRepository=orderBookRepository;
  this.tradeExecutedRepository=tradeExecutedRepository;
  this.portfolioQueryRepository=portfolioQueryRepository;
}
 

@Autowired(required=true) public void setProperties(Properties properties){
  this.adminDatastreams=this.getUnmodifiableDatastreamSetFromProperty("access.datastream.admin",new HashSet<Datastream>(),properties,",");
  this.surrogateDatastreams=this.getUnmodifiableDatastreamSetFromProperty("access.datastream.surrogate",new HashSet<Datastream>(),properties,",");
  this.fileDatastreams=this.getUnmodifiableDatastreamSetFromProperty("access.datastream.file",new HashSet<Datastream>(),properties,",");
  this.recordDatastreams=this.getUnmodifiableDatastreamSetFromProperty("access.datastream.record",new HashSet<Datastream>(),properties,",");
  this.setAdminGroup(properties.getProperty("access.group.admin",""));
  this.setPublicGroup(properties.getProperty("access.group.public",""));
}
 

@Autowired public AccountController(AccountManager accountManager){
  this.accountManager=accountManager;
  Flash flash=FacesContext.getCurrentInstance().getExternalContext().getFlash();
  flash.setKeepMessages(true);
  String id=(String)flash.get("id");
  if (id != null) {
    account=this.accountManager.getAccount(new Long(id));
    this.setId(id);
  }
}
 

@Autowired public void setDataSource(DataSource dataSource){
  jdbcTemplate=new JdbcTemplate(dataSource);
  insertMsgbase=new SimpleJdbcInsert(dataSource);
  insertMsgbase.setTableName("msgbase");
  insertMsgbase.usingColumns("id","message","bbcode");
}
 

@Autowired public void init(DataSource dataSource){
  this.simpleJdbcTemplate=new SimpleJdbcTemplate(dataSource);
  this.insertOwner=new SimpleJdbcInsert(dataSource).withTableName("owners").usingGeneratedKeyColumns("id");
  this.insertPet=new SimpleJdbcInsert(dataSource).withTableName("pets").usingGeneratedKeyColumns("id");
  this.insertVisit=new SimpleJdbcInsert(dataSource).withTableName("visits").usingGeneratedKeyColumns("id");
}
 

private void doAutoWireRemainingResources(Object target,Field[] fields) throws IllegalAccessException {
  for (  Field field : fields) {
    ReflectionUtils.makeAccessible(field);
    if (field.getAnnotation(Autowired.class) != null && field.get(target) == null) {
      field.set(target,mock(field.getType(),new DoesNothing()));
    }
  }
}
 

/** 
 * Constructor which will take in a component-scanned list of all ModelPermissionEvaluator classes found by Spring component scanner.  The constructor builds the internal Map by using the Model type (Model Class) as the key, thus ensuring only one ModelPermissionEvaluator class exists for each Model object.  The constructor first sorts the injected list of ModelPermissionEvaluator objects by the loadOrder field to allow overrides of the default ModelPermissionEvaluators.
 * @param modelPermissionEvaluatorList autowired injected list of all ModelPermissionEvaluator classes foundby the component scanner
 */
@Autowired public RavePermissionEvaluator(List<ModelPermissionEvaluator<?>> modelPermissionEvaluatorList){
  Collections.sort(modelPermissionEvaluatorList,new Comparator<ModelPermissionEvaluator>(){
    @Override public int compare(    ModelPermissionEvaluator o1,    ModelPermissionEvaluator o2){
      return new Integer(o1.getLoadOrder()).compareTo(new Integer(o2.getLoadOrder()));
    }
  }
);
  modelPermissionEvaluatorMap=new HashMap<Class,ModelPermissionEvaluator<?>>();
  for (  ModelPermissionEvaluator<?> mpe : modelPermissionEvaluatorList) {
    modelPermissionEvaluatorMap.put(mpe.getType(),mpe);
  }
}
 

@Autowired public ContainerServiceContext(@Qualifier("containerConfigurationService") ContainerConfigurationService containerConfigurationService,@Qualifier("servicePorts") ServicePorts servicePorts,@Qualifier("serviceRegistry") ServiceRegistry registry,@Qualifier("configurationManager") ConfigurationService configurationManager){
  this.containerConfigurationService=containerConfigurationService;
  this.configurationListener=new ContainerConfigurationListener();
  this.servicePorts=servicePorts;
  this.configurationManager=configurationManager;
  this.registry=registry;
}
 

@Autowired public void init(DataSource dataSource){
  this.addSqlActorProc=new AddSqlActorProc(dataSource);
  this.getSqlActorProc=new GetSqlActorProc(dataSource);
  this.addActorProc=new AddActorProc(dataSource);
  this.getActorProc=new GetActorProc(dataSource);
  this.getActorNamesProc=new GetActorNamesProc(dataSource);
  this.deleteActorsProc=new DeleteActorsProc(dataSource);
  this.readActorsProc=new ReadActorsProc(dataSource);
  this.getActorArrayProc=new GetActorArrayProc(dataSource);
  this.saveActorArrayProc=new SaveActorArrayProc(dataSource);
}
 

@Autowired @SuppressWarnings("unchecked") public void setMongo(Mongo mongo) throws Exception {
  MongoMappingContext mappingContext=new MongoMappingContext();
  mappingContext.setInitialEntitySet(new HashSet<Class<?>>(Arrays.asList(XObject.class)));
  mappingContext.initialize();
  MappingMongoConverter mappingConverter=new MappingMongoConverter(factory,mappingContext);
  mappingConverter.afterPropertiesSet();
  this.mongoTemplate=new MongoTemplate(factory,mappingConverter);
  mongoTemplate.setApplicationContext(applicationContext);
}