javaspring ioc

spring

一、spring主要解决的问题

Spring框架是为了解决企业应用开发的复杂性而创建的。
Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。使用基本的JavaBean代替EJB，并提供了更多的企业应用功能。
spring就是作为容器，用来管理struts(应用层)和hibernate(持久层)之间的工作的。它其实就是程序中的一个桥梁或者说管理者，整个程序的运行都依靠spring来管理。用什么方法来管理呢？最常见的就是IOC了。

二、spring/ioc

1. 概念：
   核心理念:inversion of conerol 控制反转，控制权从调用者转到了spring的IOC容器，由IOC容器进行实例化和依赖注入。
   控制反转：就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控。
   依赖注入：组件之间的依赖关系由容器在运行期决定 ，由容器动态的将某种依赖关系注。
2. xml配置：
   （1）、默认构造器实例化
   xml配置：
   
3. spring创建bean的三种方式：
   3.1通过构造方法创建bean（最常用）
   3.1.1 spring默认会通过无参构造方法来创建bean，如果xml文件是这样配置，则实体类中必须要有无参构造方法，无参构造方法默认会有，如果写了有参构造方法。
   还采取了默认方法创建bean,则必须手动写个无参构造方法。

<bean id="user" class="com.spring.beanTest.User">
<property name="name" value="lishi"></property>
</bean>

public User(){
	System.out.println("无参构造创建bean");
}
public User(String name){
	System.out.println("有参构造创建bean");
}

3.1.2 如果通过有参构造方法来创建bean,则xml配置文件需要通过构造方法来为属性赋值

<bean id="user" class="com.spring.beanTest.User">
<constructor-arg name="name" value="lishi"></constructor-arg>
</bean>

3.2通过静态工厂创建bean
　　 首次，先建一个类，类中有静态方法

public class UserFactory{
	public static User getUser(){
		return new User();
	}
}

然后配置文件：

<bean id="user1" class="com.spring.beanTest.UserFactory" factory-method="getUser"></bean>

即可创建bean对象

public static void main( String[] args ) {
        ApplicationContext ac =new ClassPathXmlApplicationContext("application.xml");
        类名 c =ac.getBean("c", 类名.class);
    }

3.3通过实例工厂创建bean
　　首次，先建一个类，类中有普通方法

public class UserFactory2{
	public User getUser2{
    	return new User();
    }
}

然后配置文件：首先要先创建一个userFactory2的bean,因为普通方法需要对象去调用，再通过factory-bean把userFactory2带进来

<bean id="userFactory" class="com.spring.beanTest.UserFactory2"></bean>
<bean id="user2" factory-bean="userFactory" factory-mothod="getUser2"></bean>

即可创建bean对象

public static void main( String[] args ) {
        ApplicationContext ac =new ClassPathXmlApplicationContext("application.xml");
        类名 c =ac.getBean("c", 类名.class);
    }

4. spring创建bean的三种方式：
   在Spring中依赖注入有四种方式：set注入(通常也叫属性注入)，构造函数注入，接口注入(这个现在基本不用)，注解注入(@Autowire)，下面对set方法注入，构造函数注入，以及注解注入的用法举例说明。
   1、set方法注入(属性注入)
   UserDao.java

public class UserDao{
    public void inserUser(User user){
        //具体逻辑省略
    }
}

UserService.java

public Interface UserService{
    void inserUser(User user);
}

UserServiceImpl.java

public class UserServiceImpl implements UserService{
    private UserDao userDao;
    public void setUserDao(UserDao userDao){
        this.userDao = userDao;
    }
    public void insertUser(User user){
        userDao.insert(user);
    }
}

Spring配置文件

 <bean id="userDao" class="UserDao"></bean>
 <bean id="userService" class="UserServiceImpl">
 <property name="userDao" ref="userDao">
 </bean>

以上就可以把userDao注入到UserServiceImpl中
4.2、构造函数注入
User.java

public class User{
    private String name;
    private Integer age;
    //getter/setter方法省略
    public User(String name,int age){
        this.name = name;
        this.age = age;
    }
}

现在通过Spring配置文件来注入这User这个对象

 <bean id="user" class="User">
     <constructor-arg index="0" value="zhangsan"/>
     <constructor-arg index="1" value="20>
 </bean>

以上就可以将属性值注入到User对象中。当然如果想以set方法注入的例子话，其实也一样。就是在UserServiceImpl需要构造函数，形参就是userDao了，就不需要setter方法了。那么关于其Spring的配置文件的书写应该改成这样

 <bean id="userDao" class="UserDao"></bean>
 <bean id="userService class="UserServiceImpl">
     <constructor-arg  index="0" ref="userDao">
 </bean>

4.3、注解注入
注册springbean @controller @service @Repository
自动依赖注入 @Autowired @value

@Component
public class UserDao{
    public void inserUser(User user){
        //具体逻辑省略
    }
}

UserService.java

public Interface UserService{
    void inserUser(User user);
}

UserServiceImpl.java

@Service
public class UserServiceImpl implements UserService{
    @Autowire
    private UserDao userDao;
    public void insertUser(User user){
        userDao.insert(user);
    }
}

Spring对应的配置文件

 <context:component-scan base-package="com.spring">

通过比较，注解注入要比其余注入要方便的多，代码和配置文件也写的少，在开发的过程中还是建议使用注解注入。

5. bean的作用域：
   注解用@scope(类别)
   xml:scope=“类别”
   
6. bean的生命周期：
   

1:instantiate bean对象实例化
2:populate properties 封装属性
3:如果Bean实现BeanNameAware 执行 setBeanName
4:如果Bean实现BeanFactoryAware 或者 ApplicationContextAware 设置工厂 setBeanFactory 或者上下文对象 setApplicationContext
5:如果存在类实现 BeanPostProcessor（后处理Bean） ，执行postProcessBeforeInitialization
6:如果Bean实现InitializingBean 执行 afterPropertiesSet 
7:调用<bean init-method="init"> 指定初始化方法 init
8:如果存在类实现 BeanPostProcessor（处理Bean） ，执行postProcessAfterInitialization
9:执行业务处理
10:如果Bean实现 DisposableBean 执行 destroy
11:调用<bean destroy-method="destroy"> 指定销毁方法 customerDestroy

例如：

@PostConstrust
public void init(){
	System.out.println("开始。。。。");
}
@PreDertroy
public void destroy(){
	System.out.println("销毁。。。。");
}

7. ioc的优势：
   由上面可以看出来IOC的优点有：降低了耦合性，提高程序的灵活性和可维护性。
   缺点是：如果修改了类名，还需到XML文件中手动修改。

第一次注册博客账号，第一次写博客，第一次用写的文章内容为java。不足之处，还望多多指教。