Spring入门

今个来说下Spring工厂类的问题
首先是Spring工厂
工厂就是将创建对象的权利交给Spring
Spring是如何实现工厂的？
还是在上面链接创建的项目内，具体的创建过程见上方链接。
我们依次创建一下今日的包结构 如图，此文只到demo3

springBatch菜鸟教程 spring菜鸟教程pdf_springBatch菜鸟教程


这时demo1已经做好了上次做的，然后我们配置下log4j这个文件，

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=d\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=info, stdout

我们通过在demo2内的代码来了解Bean实例化的三种方式

三种实例化Bean的方式

1、使用类构造器实例化（默认无参数）

2、使用静态工厂方法实例化（简单工厂模式）

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

demo2下的文件结构如下

springBatch菜鸟教程 spring菜鸟教程pdf_springBatch菜鸟教程_02


其中内容分别为

/**
 * Bean 的实例化的三种方式，采用无参数的构造方法的方式
 *
 */
public class Bean1 {
    public Bean1(){
        System.out.println("Bean1 被实例化了");
    }
}
/**
 * Bean的实例化的第二种，静态工厂实例化方式
 * 
 */
public class Bean2 {
}
/**
 * Bean2的静态工厂
 * 
 */
public class Bean2Factory {
    public static  Bean2 createBean2(){
        System.out.println("Bean2的工厂执行啦");
        return new Bean2();
    }
}

/**实例工厂实例化
 * 
 */
public class Bean3 {
}
/**Bean3的实例工厂
 *
 */
public class Bean3Factory {
    public Bean3 createBean3(){
        System.out.println("Bean3的工厂被执行 了");
        return new Bean3();
    }
}

为了使Spring能够识别我们的类，我们需要在Spring配置文件中进行如下配置

<!--Bean的实例化的三种方式-->
    <!--第一种无参构造器方法-->
    <bean id="bean1" class="com.imooc.ioc.demo2.Bean1"/>
    <!--第二种方式静态工厂的方式-->
    <bean id="bean2" class="com.imooc.ioc.demo2.Bean2Factory" factory-method="createBean2"/>
    <!--第三种实例工厂-->
    <bean id="bean3Factory" class="com.imooc.ioc.demo2.Bean3Factory"/>
<bean id="bean3" factory-bean="bean3Factory" factory-method="createBean3">
   </bean>

对应的测试类如下：

package com.imooc.ioc.demo2;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试Bean的实例化的三种方式
 * 
 */
public class SpringDemo2 {
    @Test
    public  void demo1(){
        //创建工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类的实例
        Bean1 bean1=(Bean1)applicationContext.getBean("bean1");
    }
    @Test
    public  void demo2(){
        //创建工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过工厂获得类的实例
        Bean2 bean2=(Bean2)applicationContext.getBean("bean2");
    }

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

}

实现效果

springBatch菜鸟教程 spring菜鸟教程pdf_spring_03

Spring容器中Bean的生命周期

Spring初始化bean或销毁bean时，有时需要做一些处理工作，因此Spring可以在创建和销毁bean的时候调用bean的两个生命周期方法

当bean被载入到容器时候调用init，当bean从容器中删除的时候调用destroy（只有scope=singleton时有效）

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、调用指定初始化方法init

8、如果存在类实现BeanPostProcessor（处理Bean），执行postProcessAfterInitialization

9、执行业务处理

10、如果Bean实现DisposableBean执行destory

11、调用指定销毁方法customerDestroy

具体代码如下，我们在demo3的包内建立如下的类

springBatch菜鸟教程 spring菜鸟教程pdf_spring_04


每个类具体的内容如下：

public class Man implements BeanNameAware,DisposableBean,ApplicationContextAware,InitializingBean{
    private String name;


    public  Man(){

        System.out.println("第一步、man被实例化了");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        System.out.println("第二步，设置属性");
        this.name = name;
    }
    @Override
    public void setBeanName(String s) {
        System.out.println("第三步、设置Bean的名称"+s);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("第四步、了解工厂信息");
    }

//第五步在MyBeanPostProcessor类中
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("第六步、属性设置后执行的");
    }

    public void setup(){
        System.out.println("第七步、执行指定的init方法man被初始化了");
    }

    //第八步在MyBeanPostProcessor类中
    public void  run(){
        System.out.println("第九步，执行自身业务方法");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("第十步、执行Spring的销毁方法");
    }

    public void teardown(){
        System.out.println("第十一步、自定义的销毁方法，man被销毁了");
    }
}


public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {

      //  System.out.println("第五步，初始化前方法");
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(final Object o, String s) throws BeansException {
     //   System.out.println("第八步，初始化后方法");
        if(s.equals("userDao")){
           Object proxy= Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object ob, Method method, Object[] objects) throws Throwable {
             if("save".equals(method.getName())){
                 System.out.println("权限校验");
                return method.invoke(o,objects);
             }
                return method.invoke(o,objects);
            }
        });
            return proxy;
        }
       else{
            return o;
        }
    }
}


public class Person {
}


public interface UserDao {
    public void find();
    public void save();
    public void update();
    public void delete();
}


public class UserDaoImpl implements UserDao {
    @Override
    public void find() {
        System.out.println("找到啦");
    }

    @Override
    public void save() {
        System.out.println("保存了");
    }

    @Override
    public void update() {
        System.out.println("更新了");
    }

    @Override
    public void delete() {
        System.out.println("删除了");
    }
}

接下来是Spring的配置

<!--Bean的作用范围-->
    <bean id="person" class="com.imooc.ioc.demo3.Person" scope="prototype"/>
<bean id="man" class="com.imooc.ioc.demo3.Man" init-method="setup" destroy-method="teardown">
    <property name="name" value="jjyu-god"/>
    </bean>
    <bean class="com.imooc.ioc.demo3.MyBeanPostProcessor"/>
<bean id="userDao" class="com.imooc.ioc.demo3.UserDaoImpl"/>

测试类

public class SpringDemo3 {
    @Test
    public  void  demo1(){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
       Person p1=(Person)applicationContext.getBean("person");
        Person p2=(Person)applicationContext.getBean("person");
        System.out.println(p1);
        System.out.println(p2);
    }
    @Test
    public  void  demo2(){

        ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Man p1=(Man) applicationContext.getBean("man");
        p1.run();
        applicationContext.close();
//        System.out.println(p1);


        applicationContext.close();

    }
    @Test
    public  void  demo3(){

        ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao=(UserDao) applicationContext.getBean("userDao");
         userDao.delete();
        userDao.find();
        userDao.save();
        userDao.update();


        applicationContext.close();

    }
}

实现效果

springBatch菜鸟教程 spring菜鸟教程pdf_ioc_05


看到这里就没啦，Spring工厂类和Spring里面Bean的生命周期，应该知道如何配置和操作了吧。