Spring

---------- Spring ---------

(1).什么是Spring
    - Spring是一个开源的轻量级的应用开发框架。
    - 目的:简化开发企业级应用程序的开发,减少侵入性(通过配置文件尽量不靠(创建对象的方法))。 // 高侵入低耦合
    - Spring提供的ioc(输入输出控制器)和aop(面向切面)的应用,可以将组建的耦合度降至最低,及解耦,便于系统日后的维护和升级。
    - Spring为系统提供了整体的解决方案,开发者可以利用它本身提供的功能之外,也可以与第三方框架和技术整合应用。

(2).为什么用Spring
    - Spring的本质是关联软件中的对象,如何创建对象以及维护对象(对象之间的调用)之间的关系。(Spring容器创建对象)

(3).Spring容器简介
    - 在Spring中,任何的java类和javaBean都被当成bean处理,这些bean通过容器管理和应用。
    - spring 容器实现了ioc和aop机制,这些机制可以简化Bean对象的创建和Bean对象之间的解耦。
    Spring 容器有两种类型:
        1.BeanFactory(工厂类/容器) 和 ApplicationContext(应用环境)
        
(4).Spring容器的实例化
    - ApplicationContext继承自 BeanFactory 接口,拥有更多的企业级方法,推荐使用该类型。

(5).如何使用spring? 
    - 遵守spring定义的规则,基于配置和默认规则,减少代码的书写。

(6).spring容器的使用
    1.首先在容器配置文件spring-mvc.xml中添加Bean定义
      <bean id="标识符" class="Bean类型">
      ~~~
      <bean id="empdao" class="com.dao.EmpDao"/>
      ~~~

    2.在创建spring容器对象之后,调用getBean()方法获取Bean的实例(根据类型创建的对象)。
      .getBean("标识符");
      ~~~
        /*  Spring容器的实例化
         *  1.new ClassPathXmlApplicationContext() 创建容器 并 加载spring-mvc.xml文件
         *  2.通过  .getBean("对应xml的id(标识符)",转换) 调用实体类对象
         * */
        // 加载spring-mvc.xml文件
        String conf = "spring-mvc.xml";
        // new ClassPathXmlApplicationContext() 创建容器
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        // 调用getBean()方法获取Bean的实例
        EmpDao dao = ac.getBean("empdao", EmpDao.class);
      ~~~

(7).Bean的实例化
    - Spring容器创建Bean对象的方法有以下三种；
        * 用构造器实例化
        * 用静态工厂方法实例化
        * 使用实例工厂方法实例化

(8).Bean命名
    - 在spring容器中,每个bean都需要有名字(即标识符),改名字可以<bean>元素的id或name属性严格,要求具有唯一性,不允许用"/"等特殊字符。
       所以推荐使用id做标识符。
    - bean的别名
        为已定义好的bean再增加另外一个名字的引用,可以使用<alias>指定。
        <alias name = "fromName" alias="toName" />

<bean id="empDao" class="com.dao.EmpDao" />
<alias name="empDao" alias="dao" />

(9).Bean的作用域(scope)
    - 用关键词scope指定不同类型的作用域,[singleton(单例模式),prototype(多例模式)]
      <bean id="empdao" class="com.dao.EmpDao" scope="prototype" /> // 默认是singleton(单例模式)

(10).Bean的声明周期(init-method) (destroy-method)
    - 指定初始化回调方法: init-method="init" [bean定义]
    - 指定销毁的回调方法: destroy-method="destroy"

(11).bean延迟实例化(lazy-init)
    - 在ApplicationContext实现的默认行为就是在开启时将所有的Singleton bean提前进行实例化。
    
      一个延迟初始化bean对象可以设置,lazy-init="true"
      EmpDao dao = ac.getBean("empDao", EmpDao.class);执行才会加载
    
(12).指定bean的依赖关系(depends-on)
    - 当一个bean对另一bean存在依赖关系时,可以利用<bean>元素的depends-on属性指定。
     <bean id="empDao" class="com.dao.EmpDao"/>
     <bean id="empDemo" class="com.dao.EmpDemo" depends-on="empDao"/> // empDemo依赖于empDao
    
    - 多个依赖关系
     <bean id="empDao" class="com.dao.EmpDao" depends-on="empDemo,empDemo2,..."/>

(13).容器的IOC应用
    - IOC全程 inversion of Control,控制反转。
    - IOC是指程序中对象的获取方式发生了反转,由最初的new方式创建,转变为由第三方框架和注入。
      * 第三方框架一般是通过配置方式指定注入哪一个具体实现,从而降低了对象之间的耦合度。
      * IOC具体实现；DI(依赖注入)
      * DI的基本原理:
            将一起工作具有关系的对象,通过构造方法参数或者方法参数传入建立关联,因此容器的工作就是创建Bean时注入那些依赖关系
            IOC是一种思想,DI是实现IOC的主要技术途径。
            DI主要有两种注入方式:即构造器注入和setter注入。
      * setter注入
            通过调用无参构造器或者无参static工厂方法实例化bean之后,调用该bean的setter方法,即可实现setter方式的注入。

<6-13>
//spring-mvc.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" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xmlns:util="http://www.springframework.org/schema/util" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd     
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
        
        <!-- 
            -构造器实例化-
            init-method 指定初始化回调方法 
            destory-method 指定销毁的回调方法
            lazy-innit="true" 延迟实例化  // .getBean()执行才会加载 回调方法
         -->
        <bean id="empdao" class="com.dao.EmpDao" init-method="init" lazy-init="true"/>
        <alias name = "empdao" alias="dao" />
        <!-- 指定bean依赖关系 depends-on(依赖注入)  -->
        <bean id="empdemo" class="com.dao.EmpDemo" depends-on="empdao"/>
        
        <!-- 静态工厂实例化 -->
        <bean id="calendar" class="java.util.Calendar" factory-method="getInstance" />
        
        <!-- 实例工厂方法实例化 -->
        <bean id="calObj" class="java.util.GregorianCalendar"/>
        <bean id="dateObj" factory-bean="calObj" factory-method="getTime"/>
        
        <!-- setter注入 -->
        <bean id="setter" class="com.dao.Setter"/>
        <bean id="setterDemo" class="com.dao.SetterDemo">
            <property name="set" ref="setter"/>
        </bean>
        
        <!-- 构造器实例化 -->
        <bean id="empdao" class="com.dao.EmpDao">
            <constructor-arg index="0" ref="dbutil"/>
        </bean>
        
        <!-- 注入字符串 -->
        <bean id="dbutil" class="com.util.DBUtil">
            <property name="driver" value="com.mysql.jdbc.Driver" />
            <property name="url" value="jdbc:mysql://localhost:3306/db_emp" />
            <property name="username" value="root" />
            <property name="password" value="root" />
        </bean>
</beans>

dao
// EmpDao

package com.dao;
import com.util.DBUtil;

public class EmpDao {
    // 声明属性
    private DBUtil util;
    //  
    public EmpDao(DBUtil util){
        this.util=util;
    }
    // 一个方法
    public void show() {
        System.out.println(util.getDriver() + "****");
    }
    // 算数方法
    public int sum(int a, int b) {
        return a + b;
    }   
}

//Setter

package com.dao;
public class Setter {
    // 算数方法
    public int sum(int a, int b) {
        return a + b;
    }
}

//SetterDemo

package com.dao;
public class SetterDemo {
    // setter 注入
    private Setter set;
    public Setter getSet() {
        return set;
    }
    public void setSet(Setter set) {
        this.set = set;
    }
    public void test(){
        int sum = set.sum(4, 4);
        System.out.println(sum);
    }
}

// 测试

package com.test;
import java.util.Date;
import java.util.GregorianCalendar;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.dao.EmpDao;
import com.dao.SetterDemo;
import com.util.DBUtil;

public class test {
    public static void main(String[] args) {
        /*  Spring容器的实例化
         *  1.new ClassPathXmlApplicationContext() 创建容器 并 加载spring-mvc.xml文件
         *  2.通过  .getBean("对应xml的id(标识符)",转换) 调用实体类对象
         * */
        // 加载spring-mvc.xml文件
        String conf = "spring-mvc.xml";
        // new ClassPathXmlApplicationContext() 创建容器
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext(conf);
        // 构造器方法实例化
        /*
        EmpDao dao = ac.getBean("empdao", EmpDao.class);
        int s = dao.sum(3, 4);
        System.out.println(s);
        // 测试初始化回调init (第一个执行输出)
        // 测试销毁回调destroy(不会输出 但是的确执行了销毁)
        */
        
        /*
        //bean别名(alias)
        EmpDao dao = ac.getBean("dao", EmpDao.class);
        int s = dao.sum(3, 4);
        System.out.println(s);
        */
        
        // 静态工厂方法实例化
        /*
        Calendar c = ac.getBean("calendar", Calendar.class);
        System.out.println(c.get(Calendar.DATE));
        */
        
        /*
        //实例工厂方法实例化
        Date g = ac.getBean("dateObj",Date.class);
        System.out.println(g);
        */
        
        /*
        //setter注入
        SetterDemo set = ac.getBean("setterDemo", SetterDemo.class);
        set.test();
        */
        
        /*  
        // 测试DBUtil
        DBUtil db = ac.getBean("dbutil", DBUtil.class);
        db.show();
        */
        
        /**/
        // 构造器注入
        EmpDao dao = ac.getBean("empdao", EmpDao.class);
        dao.show();
        
    }
    
}

// dbutil

package com.util;

public class DBUtil {
    // 关联字符串
    private String driver;
    private String url;
    private String username;
    private String password;
    
    public String getDriver() {
        return driver;
    }
    public void setDriver(String driver) {
        this.driver = driver;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    
    // 测试
    public void show(){
        System.out.println(driver+"|"+url+"|"+username+"|"+password);
    }
}

(14).自动装配
    - SpringIOC容器可以自动装配(autowire)相互协作bean之间的关联关系,autowrire可以针对单个bean进行设置,
      autowire的方便之处在于减少xml的注入配置,在xml配置文件中,可以在bean元素使用。
      autowire属性指定自动装配规则,常用类型2种:byName(按名称匹配),byType(按类型匹配)。

(15).参数值注入
    - 注入基本值
        * <value /> 元素可以通过字符串指定属性或者构造器参数的值。容器将字符串从java.lang.String类型转化为实际的属性
          或参数类型后给Bean对象注入。

(16).注入bean对象
    - 注入bean对象,定义格式有两种。
        * 注入外部bean
        * 注入内部bean

(17).注入集合
    - 通过<list>、<set>、<map>、<props> 元素可以定义和设置与java类型中的对应List、set、Map、及Properties的属性值。
    - 注入方式:
        * 外部注入
        * 内部注入
    - 注入null或空字符串
    
(18).注入Spring表达式的值
    - Spring引入一种表达式语言,这和统一的EL在语法上相似,这种表达式语言可以用于定义基于XML和注解配置的bean,
      注入一个properties文件信息。

// DBUtil

package com.util;
public class DBUtil {
    // 测试
    public void show(){
        System.out.println("DBUtil****************");
    }
    
}

// EmpDao

package com.dao;
import com.util.DBUtil;

public class EmpDao {
    // setter注入
    private DBUtil db;
    public DBUtil getDb() {
        return db;
    }
    public void setDb(DBUtil db) {
        this.db = db;
    }
    // 调用DBUtil的方法
    public void show(){
        db.show();
    }
}

//spring-mvc.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" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jpa="http://www.springframework.org/schema/data/jpa"
    xmlns:util="http://www.springframework.org/schema/util" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd
        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
        http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd     
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.2.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
        
        <!-- 
        -自动装配-
        autowire属性指定自动装配规则,常用类型2种:byName(按名称匹配),byType(按类型匹配)
        byName:对应id (db)
        -->
        <!-- 
        <bean id="empDao" class="com.dao.EmpDao" autowire="byName"/>
        <bean id="db" class="com.util.DBUtil"/>
         -->
         
        <!-- 注入基本值 -->
        <!-- 
        <bean id="action" class="com.action.EmpAction">
            <property name="age" value="18"></property>
            <property name="name" value="name"></property>
        </bean>
         --> 
        <!-- 
        <bean id="action" class="com.action.EmpAction">
            <property name="age">
                <value>18</value>
            </property>
            <property name="name">
                <value>name</value>
            </property>
        </bean>
        -->
         
        <!-- 注入外部bean对象 -->
        <!-- 
        <bean id="dd" class="com.dao.EmpDemo"/>
        <bean id="action" class="com.action.EmpAction">
            <property name="demo" ref="dd"/>
        </bean>
        -->
         
        <!-- 注入内部bean对象 -->
        <!-- 
        <bean id="action" class="com.action.EmpAction">
            <property name="demo">
                <bean class="com.dao.EmpDemo"/>
            </property>
        </bean>
        --> 
        
        <!-- 集合注入(内部注入对象) -->
        <bean id="action" class="com.action.EmpAction">
            <!-- List集合 -->
            <property name="emps" ref="emp">
                <!-- 
                <list>
                    <value>tom/list</value>
                    <value>jack/list</value>
                </list>
                 -->
            </property>
            <!-- Set集合 -->
            <property name="ems" ref="em">
                <!-- 
                <set>
                    <value>tom/set</value>
                    <value>jack1/set</value>
                </set>
                 -->
            </property>
            
            <!-- Map集合 -->
            <property name="map" ref="ma">
                <!-- 
                <map>
                    <entry key="1001" value="Java语言基础" />
                    <entry key="1002" value="JavaWeb基础" />
                    <entry key="1003" value="Spring基础" />
                </map>
                 -->
            </property>
            
            <!-- Properties集合 -->
            <property name="pp" ref="p">
                <!-- 
                <props>
                    <prop key="url">jdbc:mysql:localhost:3306/db_emp</prop>
                </props>
                 -->
            </property>
            
            <!-- 注入null或空字符串 -->
            <!-- 
            <property name="test" value="null" />
            <property name="test">
                <null />
            </property>
             -->
             
             <!-- 注入Spring表达式 -->
             <!-- 
            <property name="name" value="#{random.username}" />
            <property name="age" value="#{random.age}" />
             -->
        </bean>
        
        <!-- List集合外部注入 -->
        <util:list id="emp">
            <value>jack</value>
            <value>tom</value>
        </util:list>
        
        <!-- Set集合外部注入 -->
        <util:set id="em">
            <value>tom</value>
            <value>jack</value>
        </util:set>
        
        <!-- Map集合外部注入 -->
        <util:map id="ma">
            <entry key="1001" value="Java语言基础" />
            <entry key="1002" value="Java Web基础" />
            <entry key="1003" value="Spring基础" />
        </util:map>
        
        <!-- Properties集合外部注入 -->
        <util:properties id="p">
            <prop key="url">jdbc:mysql:localhost:3306/db_emp</prop>
        </util:properties>
        
        <!-- 注入Spring表达式 -->
        <util:properties id="random" location="classpath:com/util/db.properties"/>
</beans>

// EmpAction

package com.action;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.springframework.stereotype.Controller;
import com.dao.EmpDemo;
@Controller
public class EmpAction {
    // 成员变量 
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    // setter 注入EmpDemo
    private EmpDemo demo;
    public EmpDemo getDemo() {
        return demo;
    }
    public void setDemo(EmpDemo demo) {
        this.demo = demo;
    }
    
    /*<注入集合>*/
    // 注入List集合
    private List<String> emps;
    public List<String> getEmps() {
        return emps;
    }
    public void setEmps(List<String> emps) {
        this.emps = emps;
    }
    
    // 注入set集合
    private Set<String> ems;
    public Set<String> getEms() {
        return ems;
    }
    public void setEms(Set<String> ems) {
        this.ems = ems;
    }
    
    // 注入map集合
    private Map<String,String> map;
    public Map<String, String> getMap() {
        return map;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    
    // properties集合
    private Properties pp;
    public Properties getPp() {
        return pp;
    }
    public void setPp(Properties pp) {
        this.pp = pp;
    }
    
    //
    private String test;
    public String getTest() {
        return test;
    }
    public void setTest(String test) {
        this.test = test;
    }
    
    // 扫描测试
    public void dd(){
        System.out.println("ddddddddd");
    }
}

// EmpDemo

package com.dao;
public class EmpDemo {
    public void show(){
        System.out.println("&&&&&&&&&&&&&&&&&&&&");
    }
}

(19).基于注解的组件扫描
    - 什么是组件扫描?
        * 指定一个包路径,spring会自动扫描该包下及其子包下的所有组件类,当发现组件类定义前有特定的注解标记时,
          就会将该组件纳入到spring容器中。等价于原xml配置文件中的 bean定义。
            // 扫描com.dap下的所有文件
            <context: component-scan base-package="com.dao">
            
    - 自动扫描注解标记
        * 指定扫描路径后,并不是所有该路径下的组件类都被扫描到spring容器中,只有在组件类定义前有以下注解标记的
          才会被扫描spring容器中。
          
          注:当一个组件在扫描过程中被监测到时,会生成一个默认id值,默认id为小写开头的类名。
          |— — — — — — — — — — — — — — — — — — —|
          |  [注解标记]     |    [标记描述]     |
          |— — — — — — — — — — — — — — — — — — —|
          |  [ @Component ] | [ 通用注解 ]      |
          |  [ @Name ]      | [ 通用标记 ]      |
          |  [ @Repository ]| [ 持久层组件注解 ]|          
          |  [ @Service ]   | [ 业务层组件注解 ]|
          |  [ @Controller ]| [ 控制层组件注解 ]|
          |— — — — — — — — — — — — — — — — — — —|
           
    - 指定依赖注入关系
        * 具有依赖关系的Bean对象,利用@Resource[依赖注入]实现依赖关系注入。
        * @Resource 标记可以用在字段定义(成员变量)上。或者setter方法定义上。
        * 默认首先按名称匹配注入,然后按照类型匹配注入。