Spring【基础部分】

一　　Spring框架的目的

　　不用Spring，用Struts2和Hibernate也可以做项目，Spring只是改善架构的框架。

　  思考：Spring怎么解决架构性的问题？怎么让架构变得更好？

　　

　　Spring是一个基于core(Ioc容器)来架构多层JavaEE系统的框架，他的主要目的是简化企业开发

　　Spring是一种非侵入式的方式来管理你的代码。Spring提倡“最少侵入”。这也意味着你可以适当的时候安装或卸载Spring。

 　  你不需要知道Spring的API，只是需要了解Spring启动的api，其他的根本不用涉及。

---

二　　Spring IOC

　　Spring的控制反转：把对象的创建，初始化，销毁等工作交给spring容器来做，由spring容器控制对象的生命周期。　

　　好处：让程序员把关注点不在放在对象创建与销毁上，把注意力转移到业务逻辑开发上。　

---

  

三　　Spring的第一个案例　　

　　使用Spring-framework-2.5.6的版本，之所以用2.5因为只需要导入一个jar包，随着版本越高，需要的版本的越高

　　(1)导入jar包

　　　　1.　　spring.jar

　　　　2.　　commons-logging-1.1.3.jar

　　(2)创建HelloWorld类

public class HelloWorld {
    public void hello(){
        System.out.println("hello world !");
    }
}

　　(3)根目录下创建配置文件

　　　　名字为:applicationContext.xml

　　　　格式为:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <!-- 
        把一个类放入到spring容器中，就是一个bean
        id:唯一标识
        class:完整类名
     -->
     <bean id="helloWorld" class="spring.createObject.HelloWorld">
     </bean>
</beans>

　　(4)使用

    @Test
    public void test_hello(){
        /**
         * ApplicationContext就是spring的总容器 
         */
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml"); //启动spring容器
        HelloWorld helloWorld=(HelloWorld)context.getBean("helloWorld");
        helloWorld.hello();
    }

　

ApplicationContext就是Spring的总容器，ApplicationContext是一个接口

　　　　

　　　　ConfigurableApplicationContext:

　　　　　　　　可配置容器，在单元测试的时候使用，我们上述的ClassPathXmlApplicationContext就是其的实现类的子类

　　　　WebApplicationContext:

　　　　　　　　web容器，在整合三大框架的使用

　　　总结：通过这个例子，我看到Spring容器帮我们创建了对象，我们只需要通过id这个唯一标识就可以获得对象

---

四　　Spring对象的创建方式

Spring对象创建方式有三种：

　　方式一：默认构造函数创建对象

　　　　验证：给Student类的默认构造函数添加了一句话

　　　　使用：

　　　　　 （1）在配置文件中这样使用

　　　　<bean id="student" class="spring.domain.Student"></bean>

　　　　　　(2)  使用

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml"); //启动spring容器
        Student student=(Student)context.getBean("student");
        student.say();

　　　　　　(3)控制台输出

　　　　Student类的默认构造函数被调用了
　　　　我是student

　　方式二：静态工厂

　　　　使用：

　　　　　　(1) 创建静态工厂类

public class StudentFactory {
    public static Student getStudent(){
        return new Student();
    }
}

　　　　　　(2) 修改配置文件

<bean id="studentFactory" class="spring.method.factory.StudentFactory" factory-method="getStudent"></bean>

　　　　

　　方式三：实例工厂

　　　　实例工厂解释：

　　　　　　设计模式-工厂模式有两种：

　　　　　　　　（1）简单工厂

　　　　　　　　　　　　封装new方法，并且这方法是静态的

　　　　　　　　（2）抽象工厂

　　　　　　　　　　　　 针对不同的实例，需要不同的实例工厂

　　　　(1) 创建实例工厂

public class StudentFactory {
    public Student getStudent(){
        return new Student();
    }
}

　　　　(2) 修改配置文件

　　 <bean id="factory" class="spring.method.factory.StudentFactory"></bean>
    <bean id="studentFactory" factory-bean="factory" factory-method="getStudent"></bean>

　　　　

---

五。alias 别名

    <bean id="factory" class="spring.method.factory.StudentFactory"></bean>
        <!-- 给唯一标识符 再起一个名字，可以有多个名字-->
    <alias name="factory" alias="sf"/>
    <bean id="studentFactory" factory-bean="sf" factory-method="getStudent"></bean>

---

六。Spring创建对象的时机

两个时机创建对象：

　　   (一)启动Spring容器的时候

　　条件：默认值

　　优点: 

　　　　在spring容器启动的时候创建对象，所以只要配置文件书写错误，在启动的时候就能发现错误

　　　(二) getBean的时候

　　条件：lazy-init 属性　　

　　修改配置文件：

<bean id="helloWorld2" class="spring.createObject.HelloWorld" lazy-init="true">
</bean>

---

　　 

七。Spring创建的对象是单例的还是多例的

　　

　　　证明：看对象的hashCode码。

　　结论：在Spring容器中的对象，默认是单例的

　　　单例需要注意的问题：

　　　　　　线程安全问题：　如果在类上声明属性，该属性中含有数据，该属性将是全局的　　

　　　　　　

• 　　让Spring容器中的对象，变成多例　　　　　

 <bean id="helloWorld2" class="spring.createObject.HelloWorld" scope="prototype">

　　　多例需要注意的问题：

　　　　　对象的创建时机问题:无论lazy-init是false还是true，在getBean()的时候创建对象(意味着自动让lazy-init="true")

　　　注意：action是多例的。将来strus2和spring整合时，让spring创建action。则需要使用scope="prototype"。

　　　　 

---

八。对象的init和destroy时机

　　(1)给对象添加init和destroy方法

public class Student {
    private Integer id;
    private String name;
    
    public void init(){
        System.out.println("student对象Init");
    }
    public void destory(){
        System.out.println("student对象destroy");
    }
    public Student(){
        System.out.println("Student类的默认构造函数被调用了");
    }
    public void say(){
        System.out.println("我是student");
    }
        generator getter and setter
}

　　(2)修改配置文件

    <bean id="student" class="spring.domain.Student" lazy-init="true" scope="prototype"
    init-method="init" destroy-method="destroy"></bean>

　　(3)使用

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml"); //启动spring容器
        Student student=(Student)context.getBean("student");
        System.out.println(student);
        student.say();

　　(4)看控制台输出

Student类的默认构造函数被调用了
student对象Init
spring.domain.Student@7ebc7f3f
我是student

结论：

　　　没有输出destroy方法，我们需要手动关闭spring容器

　　   在构函数之后，立刻执行init方法（有很大用途）

　　　spring容器执行了close方法之前，执行destroy方法

---

九。Spring流程

　　1.创建一个Spring容器对象

　　2.默认情况，调用构造函数。创建Spring容器中的对象

　　　　ps：该对象是单例的，且lazy-init不能为true

　　3.创建完对象后，执行对象的init方法

　　4.利用context.getBean(...)得到一个对象。

　　　　ps，在调用方法中，如该实例被设置了多例，或者lazy-init为true的情况下，则创建对象

　　5.对象调用业务逻辑方法

　　6。在Spring容器关闭之前，执行destroy方法

---

十。DI(依赖注入)

　　解释DI：给属性赋值

　　所谓的给属性赋值，就是给以下这些Hibernate类型数据赋值,在Hibernate中只有引用类型和基本类型两种

private Long pid; 
private String name;   
private Student student //引用类型
private List list;
private Set set;
private Map map;
private Property property; //枚举是一个引用
private Object[] object;

　　

　两种情况下给属性赋值：

　　情况一：xml

　　　　两种方法给属性赋值（专业术语：装配）

　　　　　　方法一：setter

　　　　　　　　前提：要有默认构造函数

　　　　　　　　基本类型用value，引用类型用ref。分别赋值。

    <bean id="student" class="spring.domain.Student" lazy-init="false">
        <property name="id" value="1"></property>
        <property name="name" value="小明"></property>
    </bean>
    <bean id="person" class="spring.domain.Person">
        <property name="student" ref="student"></property>
    </bean>

　　　　　　　　其中引用类型赋值还可以这样写(标准)

    <bean id="person" class="spring.domain.Person">
        <property name="student">
             <ref bean="student"/>
         </property>
    </bean>

　　　　　　方法二：构造函数

　　　　　　　　　(1)增加构造函数

    public Student(String name){
        this.name=name;
    }

　　　　　　　　　(2)修改配置文件

    <bean id="student" class="spring.domain.Student" lazy-init="false">
        <property name="id" value="1"></property>
        <!-- 
            <constructor-arg>指的是构造器中的参数
                index角标 从0开始
                value
                ref
         -->
        <constructor-arg index="0" value="构造器给我的名字"></constructor-arg>
    </bean>

　　情况二:  注解引用类型

　　注解一：使用@Resource注解(@Resource是java的,下面的例子都是该注解)

　　注解二：使用@Autowired(按照类型匹配)

　　　　　　使用@Qualifier(按照名称匹配)　

　

我们使用注解一@Resource的方式：

　1.　注解引用类型属性:

class Person( 
 　@Resource
    private Student student;
    ...
}　　

　　配置文件长这样:

    <bean id="student" class="spring.domain.Student">
    </bean>   
    <bean id="person" class="spring.domain.Person">
    </bean> 

　　我们这样使用，

        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml"); //启动spring容器
        Person x=(Person)context.getBean("person");
        x.getStudent().say();
        ClassPathXmlApplicationContext classPathXmlApplicationContext=(ClassPathXmlApplicationContext)context;
        classPathXmlApplicationContext.close();

　　【结论】：这样子注解属性，我们获得了student实例。

　　【Spring注解属性的原理】

　　1　　当Spring容器启动的时候，创建bean对象

　　2　　当Spring容器解析到<context:annotation-config></context:annotation-config>

　　　  　Spring容器会在Spring容器管理的bean范围内查找这些类的属性上面是否加了@Resource注解

　　3　　Spring解析到@Resource注解的name属性

　　　　　　如果name属性为“”(默认为“”)

　　　　　　　　Spring容器会得到该注解所在的属性的名称和spring容器中的id做匹配。

　　　　　　　　　　如果匹配成功，则赋值。　　

　　　　　　　　　　如果匹配不成功，则按类型进行匹配　　　　　　　　　

　　　　　　如果name属性的值不为“”

　　　　　　　　按照name属性和spring容器中的id属性进行匹配

　　　　　　　　　　如果匹配成功，则赋值

　　　　　　　　　　不成功，则报错

　　说明：

　　　　注解只能用于引用类型

　　　　注解写法比较简单，但是效率比较低

　　　　xml写法比较复杂，效率比较高

 　　

---

十一。IOC和DI结合的意义-Java代码段完全的面向接口编程

　　　　我们之前使用Dao的时候，通常这样用Dao dap=new StudentDaoImpl()。针对不同的表new不同的Dao。操作的是使用Dao接口中的方法，这是不完全的面向接口编程。因为我们是手动new的方法(硬编码)来给Dao赋值的，

　　　　现在我们用iod和di。可以写一个bean，来实现完全的面向接口编程

---

十二。Spring容器的继承

案例：XianStudent继承了Student。Student中有name属性和getter和setter方法

情形一：

    <bean id="xian" class="spring.domain.XianStudent">
        <property name="name" value="ahahaha"></property>
    </bean>

控制台输出

　　父类构造方法

　　ahahaha

情形二:

    <bean id="xian" class="spring.domain.XianStudent">
        <constructor-arg index="0" value="西西奥明"></constructor-arg>
    </bean>

控制台输出:

　　西西奥明

　　

情形三：（标准）

     <bean id="student" class="spring.domain.Student">
         <property name="name" value="小明"></property>
    </bean>  
    <bean id="xian" class="spring.domain.XianStudent" parent="student">
    </bean>

---

十三。注解类@Component

　　（1）用Component注解类

@Component
public class Person {
    @Resource
    private Student student;
        。。。。
}

　　（2）修改配置文件

　　只用写下面一句话，其他都不用写

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

　　

 【Spring类扫描原理】

　　1.启动Spring容器，Spring容器解析配置文件，

　　2.当解析到<context:component-scan base-package=".."></context:..>

　　　　就会在base-package指定的包及子包中扫描所有的类，看哪些类上面有@Component注解

　　3.如果有该注解，则有如下的规则

　　　　@Component

　　　　public class DaoImpl(){}

　　　　翻译为如下：

　　　　<bean id="daoImpl" class="..."></bean>

　　　　@Component("daoImpl2")

　　　　public class DaoImpl{}

　　　　<bean id="daoImpl2" class=".."/>

　　　4.按照@Resource注解的规则进行赋值