Spring之容器：IOC（3）

packagecom.atguigu.spring6.bean;
publicclassUser {
privateIntegerid;
privateStringusername;
privateStringpassword;
privateIntegerage;
publicUser() {
    }
publicUser(Integerid, Stringusername, Stringpassword, Integerage) {
this.id=id;
this.username=username;
this.password=password;
this.age=age;
    }
publicIntegergetId() {
returnid;
    }
publicvoidsetId(Integerid) {
this.id=id;
    }
publicStringgetUsername() {
returnusername;
    }
publicvoidsetUsername(Stringusername) {
this.username=username;
    }
publicStringgetPassword() {
returnpassword;
    }
publicvoidsetPassword(Stringpassword) {
this.password=password;
    }
publicIntegergetAge() {
returnage;
    }
publicvoidsetAge(Integerage) {
this.age=age;
    }
@OverridepublicStringtoString() {
return"User{"+"id="+id+", username='"+username+'\''+", password='"+password+'\''+", age="+age+'}';
    }
}

@TestpublicvoidtestBeanScope(){
ApplicationContextac=newClassPathXmlApplicationContext("spring-scope.xml");
Useruser1=ac.getBean(User.class);
Useruser2=ac.getBean(User.class);
System.out.println(user1==user2);
}

publicclassUser {
privateIntegerid;
privateStringusername;
privateStringpassword;
privateIntegerage;
publicUser() {
System.out.println("生命周期：1、创建对象");
    }
publicUser(Integerid, Stringusername, Stringpassword, Integerage) {
this.id=id;
this.username=username;
this.password=password;
this.age=age;
    }
publicIntegergetId() {
returnid;
    }
publicvoidsetId(Integerid) {
System.out.println("生命周期：2、依赖注入");
this.id=id;
    }
publicStringgetUsername() {
returnusername;
    }
publicvoidsetUsername(Stringusername) {
this.username=username;
    }
publicStringgetPassword() {
returnpassword;
    }
publicvoidsetPassword(Stringpassword) {
this.password=password;
    }
publicIntegergetAge() {
returnage;
    }
publicvoidsetAge(Integerage) {
this.age=age;
    }
publicvoidinitMethod(){
System.out.println("生命周期：3、初始化");
    }
publicvoiddestroyMethod(){
System.out.println("生命周期：5、销毁");
    }
@OverridepublicStringtoString() {
return"User{"+"id="+id+", username='"+username+'\''+", password='"+password+'\''+", age="+age+'}';
    }
}

@TestpublicvoidtestLife(){
ClassPathXmlApplicationContextac=newClassPathXmlApplicationContext("spring-lifecycle.xml");
Userbean=ac.getBean(User.class);
System.out.println("生命周期：4、通过IOC容器获取bean并使用");
ac.close();
}

packagecom.atguigu.spring6.process;
importorg.springframework.beans.BeansException;
importorg.springframework.beans.factory.config.BeanPostProcessor;
publicclassMyBeanProcessorimplementsBeanPostProcessor {
@OverridepublicObjectpostProcessBeforeInitialization(Objectbean, StringbeanName) throwsBeansException {
System.out.println("☆☆☆"+beanName+" = "+bean);
returnbean;
    }
@OverridepublicObjectpostProcessAfterInitialization(Objectbean, StringbeanName) throwsBeansException {
System.out.println("★★★"+beanName+" = "+bean);
returnbean;
    }
}

/** Copyright 2002-2020 the original author or authors.** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      https://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/packageorg.springframework.beans.factory;
importorg.springframework.lang.Nullable;
/*** Interface to be implemented by objects used within a {@link BeanFactory} which* are themselves factories for individual objects. If a bean implements this* interface, it is used as a factory for an object to expose, not directly as a* bean instance that will be exposed itself.** <p><b>NB: A bean that implements this interface cannot be used as a normal bean.</b>* A FactoryBean is defined in a bean style, but the object exposed for bean* references ({@link #getObject()}) is always the object that it creates.** <p>FactoryBeans can support singletons and prototypes, and can either create* objects lazily on demand or eagerly on startup. The {@link SmartFactoryBean}* interface allows for exposing more fine-grained behavioral metadata.** <p>This interface is heavily used within the framework itself, for example for* the AOP {@link org.springframework.aop.framework.ProxyFactoryBean} or the* {@link org.springframework.jndi.JndiObjectFactoryBean}. It can be used for* custom components as well; however, this is only common for infrastructure code.** <p><b>{@code FactoryBean} is a programmatic contract. Implementations are not* supposed to rely on annotation-driven injection or other reflective facilities.</b>* {@link #getObjectType()} {@link #getObject()} invocations may arrive early in the* bootstrap process, even ahead of any post-processor setup. If you need access to* other beans, implement {@link BeanFactoryAware} and obtain them programmatically.** <p><b>The container is only responsible for managing the lifecycle of the FactoryBean* instance, not the lifecycle of the objects created by the FactoryBean.</b> Therefore,* a destroy method on an exposed bean object (such as {@link java.io.Closeable#close()}* will <i>not</i> be called automatically. Instead, a FactoryBean should implement* {@link DisposableBean} and delegate any such close call to the underlying object.** <p>Finally, FactoryBean objects participate in the containing BeanFactory's* synchronization of bean creation. There is usually no need for internal* synchronization other than for purposes of lazy initialization within the* FactoryBean itself (or the like).** @author Rod Johnson* @author Juergen Hoeller* @since 08.03.2003* @param <T> the bean type* @see org.springframework.beans.factory.BeanFactory* @see org.springframework.aop.framework.ProxyFactoryBean* @see org.springframework.jndi.JndiObjectFactoryBean*/publicinterfaceFactoryBean<T> {
/*** The name of an attribute that can be* {@link org.springframework.core.AttributeAccessor#setAttribute set} on a* {@link org.springframework.beans.factory.config.BeanDefinition} so that* factory beans can signal their object type when it can't be deduced from* the factory bean class.* @since 5.2*/StringOBJECT_TYPE_ATTRIBUTE="factoryBeanObjectType";
/*** Return an instance (possibly shared or independent) of the object* managed by this factory.* <p>As with a {@link BeanFactory}, this allows support for both the* Singleton and Prototype design pattern.* <p>If this FactoryBean is not fully initialized yet at the time of* the call (for example because it is involved in a circular reference),* throw a corresponding {@link FactoryBeanNotInitializedException}.* <p>As of Spring 2.0, FactoryBeans are allowed to return {@code null}* objects. The factory will consider this as normal value to be used; it* will not throw a FactoryBeanNotInitializedException in this case anymore.* FactoryBean implementations are encouraged to throw* FactoryBeanNotInitializedException themselves now, as appropriate.* @return an instance of the bean (can be {@code null})* @throws Exception in case of creation errors* @see FactoryBeanNotInitializedException*/@NullableTgetObject() throwsException;
/*** Return the type of object that this FactoryBean creates,* or {@code null} if not known in advance.* <p>This allows one to check for specific types of beans without* instantiating objects, for example on autowiring.* <p>In the case of implementations that are creating a singleton object,* this method should try to avoid singleton creation as far as possible;* it should rather estimate the type in advance.* For prototypes, returning a meaningful type here is advisable too.* <p>This method can be called <i>before</i> this FactoryBean has* been fully initialized. It must not rely on state created during* initialization; of course, it can still use such state if available.* <p><b>NOTE:</b> Autowiring will simply ignore FactoryBeans that return* {@code null} here. Therefore it is highly recommended to implement* this method properly, using the current state of the FactoryBean.* @return the type of object that this FactoryBean creates,* or {@code null} if not known at the time of the call* @see ListableBeanFactory#getBeansOfType*/@NullableClass<?>getObjectType();
/*** Is the object managed by this factory a singleton? That is,* will {@link #getObject()} always return the same object* (a reference that can be cached)?* <p><b>NOTE:</b> If a FactoryBean indicates to hold a singleton object,* the object returned from {@code getObject()} might get cached* by the owning BeanFactory. Hence, do not return {@code true}* unless the FactoryBean always exposes the same reference.* <p>The singleton status of the FactoryBean itself will generally* be provided by the owning BeanFactory; usually, it has to be* defined as singleton there.* <p><b>NOTE:</b> This method returning {@code false} does not* necessarily indicate that returned objects are independent instances.* An implementation of the extended {@link SmartFactoryBean} interface* may explicitly indicate independent instances through its* {@link SmartFactoryBean#isPrototype()} method. Plain {@link FactoryBean}* implementations which do not implement this extended interface are* simply assumed to always return independent instances if the* {@code isSingleton()} implementation returns {@code false}.* <p>The default implementation returns {@code true}, since a* {@code FactoryBean} typically manages a singleton instance.* @return whether the exposed object is a singleton* @see #getObject()* @see SmartFactoryBean#isPrototype()*/defaultbooleanisSingleton() {
returntrue;
    }
}

packagecom.atguigu.spring6.bean;
publicclassUserFactoryBeanimplementsFactoryBean<User> {
@OverridepublicUsergetObject() throwsException {
returnnewUser();
    }
@OverridepublicClass<?>getObjectType() {
returnUser.class;
    }
}

@TestpublicvoidtestUserFactoryBean(){
//获取IOC容器ApplicationContextac=newClassPathXmlApplicationContext("spring-factorybean.xml");
Useruser= (User) ac.getBean("user");
System.out.println(user);
}

packagecom.atguigu.spring6.autowire.controllerpublicclassUserController {
privateUserServiceuserService;
publicvoidsetUserService(UserServiceuserService) {
this.userService=userService;
    }
publicvoidsaveUser(){
userService.saveUser();
    }
}

packagecom.atguigu.spring6.autowire.servicepublicinterfaceUserService {
voidsaveUser();
}

packagecom.atguigu.spring6.autowire.service.implpublicclassUserServiceImplimplementsUserService {
privateUserDaouserDao;
publicvoidsetUserDao(UserDaouserDao) {
this.userDao=userDao;
    }
@OverridepublicvoidsaveUser() {
userDao.saveUser();
    }
}

packagecom.atguigu.spring6.autowire.daopublicinterfaceUserDao {
voidsaveUser();
}

packagecom.atguigu.spring6.autowire.dao.implpublicclassUserDaoImplimplementsUserDao {
@OverridepublicvoidsaveUser() {
System.out.println("保存成功");
    }
}

@TestpublicvoidtestAutoWireByXML(){
ApplicationContextac=newClassPathXmlApplicationContext("autowire-xml.xml");
UserControlleruserController=ac.getBean(UserController.class);
userController.saveUser();
}