spring知识总结01

spring所需的jar包

<dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-core</artifactId>
       <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

使用spring编程

ApplicationContext第一种:

 //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类
       UserService userService=(UserService) applicationContext.getBean("userService");
       userService.sayHello();

ApplicationContext第二种:

 //创建Spring的工厂类
        ApplicationContext applicationContext=new FileSystemXmlApplicationContext("d:\\applicationContext.xml");
        //通过工厂获得工厂类
        UserService userService=(UserService) applicationContext.getBean("userService");
        userService.sayHello();

SpringIOC和DI

IOC就是将创建对象的控制权交给了Spring框架管理。
DI就是依赖注入，依赖于IOC，在Spring创建对象的时候将对象的属性也注入进去。

<!--IOC控制反转，创建对象-->
    <bean id="userService" class="com.zs.demo1.UserServiceImpl">
        <!--DI依赖注入成员变量-->
        <property name="name" value="zhang"></property>
    </bean>

BeanFactory与ApplicatiomContext区别

• applicationContext的功能要更多一些。
• BeanFactory与ApplicationContext生成bean实例的时机不同：BeanFactory是在工厂实例化完后去调用getBean的时候才会去创建对象的实例，applicationContext是在加载配置文件的时候，就会将配置文件中的所有单例模式生成的类全部实例化。

Spring的Bean管理

三种实例化bean的方式

• 使用类的无参构造方法（默认这种）

package com.zs.demo2;
/**
 * 无参构造方法
 */
public class Bean1 {
    public Bean1(){
        System.out.println("第一种：无参构造");
    }
}

  <!--第一种：无参构造实现-->
    <bean id="bean1" class="com.zs.demo2.Bean1"></bean>

@Test
    public void demo1(){
        //创建工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationCOntext.xml");
        //通过工厂获得类的实例
        Bean1 bean1=(Bean1)applicationContext.getBean("bean1");
    }

• 使用静态工厂方法实例化（工厂模式）

package com.zs.demo2;
/**
 * 静态工厂方法实例化
 */
public class Bean2 {
}

package com.zs.demo2;
/**
 * Bean2的静态工厂
 */
public class Bean2Factory {
    public  static Bean2 createBean2(){
        System.out.println("第二种：静态工厂方法实例化");
        return new  Bean2();
    }
}

 <!--第二种：静态工厂方法实例化实现-->
    <bean id="bean2" class="com.zs.demo2.Bean2Factory" factory-method="createBean2"></bean>

  @Test
    public void demo2(){
        //创建工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationCOntext.xml");
        //通过工厂获得类的实例
        Bean2 bean2=(Bean2) applicationContext.getBean("bean2" );
    }

• 使用实例工厂方法实例化（工厂方法模式）

package com.zs.demo2;
/**
 * 实例工厂方法实例化
 */
public class Bean3 {
}

package com.zs.demo2;
/**
 * Bean3的静态工厂
 */
public class Bean3Factory {
    public Bean3 createBean3(){
        System.out.println("第三种：实例工厂方法实例化");
        return   new Bean3();
    }
}

<!--第三种：实例工厂方法实例化实现-->
    <bean id="bean3Factory" class="com.zs.demo2.Bean3Factory"></bean>
    <bean id="bean3" factory-bean="bean3Factory" factory-method="createBean3"></bean>

 @Test
    public void demo3(){
        //创建工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationCOntext.xml");
        //通过工厂获得类的实例
        Bean3 bean3=(Bean3) applicationContext.getBean("bean3" );
    }

Bean的常用配置

• id和name:id和name在中都要唯一，区别在于，名称中含有特殊字符使用name
• class:用于设置一个类的完全路径名称，主要生成类的实例

Bean的作用域

类别	说明
singleton	在SpringIOC容器中仅存在一个Bean实例，以 单实例的方式存在
prototype	每次调用getBean()时都会返回一个新的实例
request	每次HTTP请求都会创建一个新的Bean,该作用域仅使适用于WebApplicationContext环境
session	同一个HTTP Session共享一个Bean，不同的HTTP Session使用不同的Bean。该作用域仅适用于WebApplicationContext环境

Bean的整个生命周期

Spring在创建和销毁bean的时候调用bean的两个生命周期方法。

<bean id="" class="" init-method="" destroy-method=""></bean>

init-method：当bean被载入到容器的时候调用里面的方法
destroy-method：当bean从容器中删除的时候调用里面的方法（单例模式有效）

1. instantiate bean对象实例化
2. popuplate properties封装属性
3. 如果Bean实现BeanNameAware执行setBeanName
4. 如果Bean实现BeanFactoryAway或者ApplicationContextAware设置工厂setBeanFactory或者上下文对象setApplicationContext
5. 如果存在类实现BeanPostProcessor(后处理Bean)，执行postProcessBeforeInitialization(重点！！！)
6. 如果Bean实现InitializingBean执行afterPropertiesSet
7. 调用中的指定初始化方法
8. 如果存在类实现BeanPostProcessor(处理Bean)，执行postProcessAfterInitialization(重点！！)
9. 执行业务处理
10. 如果Bean实现DisposableBean执行destroy
11. 调用中的指定销毁方法

package com.zs.demo3;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class Person implements BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean {
    private String name;
    public String getName() {
        return name;
    }
   public void setName(String name) {
        System.out.println("第二步：设置属性");
        this.name = name;
    }
    public Person(){
        System.out.println("第一步：初始化");
    }

    public void setUp(){
        System.out.println("第七步：Person被初始化");
    }
    public void destroyDown(){
        System.out.println("第十一步：Person被销毁了");
    }
   @Override
    public void setBeanName(String s) {
        System.out.println("第三步：设置Bean的名称");
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("第四步：了解工厂的信息");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("第六步：属性设置后");
    }
    public void run(){
        System.out.println("第九步：执行业务方法");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("第十步：执行Spring中的销毁方法");
    }
}

package com.zs.demo3;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPostProcess implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String s) throws BeansException {
        System.out.println("第五步：初始化前方法");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String s) throws BeansException {
        System.out.println("第八步：初始化后方法");
        return bean;
    }
}

 <bean id="person" class="com.zs.demo3.Person" init-method="setUp" destroy-method="destroyDown">
        <property name="name" value="zhangsan"></property>
    </bean>
    <bean class="com.zs.demo3.MyBeanPostProcess"></bean>

BeanPostProcessor的作用

package com.zs.demo3;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;
import java.lang.reflect.Method;
public class MyBeanPostProcess implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String s) throws BeansException {
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String s) throws BeansException {
        if ("userDao".equals(s)){
           Object proxy= Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                    if ("select".equals(method.getName())){
                        System.out.println("权限校验=======");
                        method.invoke(bean,objects);
                    }
                    return method.invoke(bean,objects);
                }
            });
            return proxy;
        }else {
            return bean;
        }
    }
}

对类进行增强，对其功能性完善

Spring的属性注入——Set方法注入

在配置文件中通过标签设置注入的属性