spring

1.spring是什么？

stuuts是web框架（jsp、zactionactionfrom）
hibernate是orm框架，处于持久层。
spring是容器框架，用于配置bean，并维护bean之间关系的框架
spring中有一个非常概念：bean是java中任何一种对象javabean、service、action，数据源，dao，ioc(控制反转inverse of control)，di(dependency injection 依赖注入)

2.快速入门：

1.引入spring的开发包
2.创建spring的核心文件。applicationContext.xml该文件一般放在src目录下

3.在applicationContext.xml中配置bean

<?xml version="1.0" encoding="UTF-8"?>
<!--
  - Middle tier application context definition for the image database.
  -->
<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:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
        <!-- 在容器文件中配置bean -->
        <!-- bean元素作用 当我们spring框架加载时，spring就会自动创建一个bean -->
        <bean id="userService" class="com.service.UserService">
            <!-- 这里就是注入 -->
            <property name="name">
                <value>biaobiao</value>
            </property>
        </bean>
</beans>

4.在Test.java中使用

//1.得到spring容器的applicationContext对象（容器对象）
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService us = (UserService) ac.getBean("userService");
        us.sayHello();

上面的功能等同于

UserService us = new UserService();
us.setName("biaobiao");
us.sayHello();

注：
UserService.java

package com.service;
public class UserService {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void sayHello(){
        System.out.println("hello world  " + name);
    }
}

5.细节讨论
传统方法和使用spring方法
5.1 使用spring没有new对象，我们把创建对象那个的任务交给spring框架。

当ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");执行的时候，我们的spring容器对象被创建，同时，applicationContext.xml中配置的bean就会被创建。

3.spring运行原理：

【图片】

spring实际上是一个容器框架，可以配置各种bean，并且可以维护bean与bean的关系，我们需要使用某个bean的时候，我们可以getBean（id)使用即可。

IOC是什么：

ioc （inverse of controll）控制反转，控制反转就是把创建对象（bean），和维护对象（bean）的关系的权利从程序中转移到spring的容器中（applicationContext.xml），而程序本身不再维护。

DI是什么：

di（dependency injection）依赖注入：实际上di和ioc是同一个概念，spring设计者认为di更准确表示spring核心技术。

学习框架最重要的就是学习各个配置。

把ApplicationContext做成一个单例。

使用BeanFactory获取bean：

//使用beanfactory获取bean
        BeanFactory bf = new XmlBeanFactory(new ClassPathResource("com/test/Beans.xml"));

我们使用beanfactory去获取bean，当实例化该容器的时候，该容器的bean不被实例化，只有当你去使用getBean某个bean时，才会实时的创建。好处就是节约内存，缺点就是速度比较慢。
（使用这句时ChangUpper cu = (ChangUpper) bf.getBean("ChangUpper");
才会被实例化。）

使用ApplicationContext获取bean

而使用ApplicationContext时，只要ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");这一句时bean就会被实例化。不管理用不用都被会实例化，好处就是可以预先加载，缺点就是耗费内存。

一般没有特殊要求，应当使用ApplicationContext完成。（90%）

bean scope：

singliton:单例，默认值（每次获取都都是同一个），在每个Spring IoC容器中一个bean定义对应一个对象实例。
prototype:原型（每次获取的都不是同一个），一个bean定义对应多个对象实例。
request:在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例， 它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。
session:在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
global-session:在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。

三种获取ApplicationContext应用的三种方法：

1. ClassPathXmlApplicationContext--->通过类路径来获取

ApplicationContext ac = new ClassPathXmlApplicationContext("com/test/Beans.xml");

1. FileSystemXmlApplicationContext--->通过文件路径

ApplicationContext ac = new FileSystemXmlApplicationContext("F:\\java\\work_1\\spring\\src\\com\\test\\Beans.xml");

1. XmlWebApplicationContext

3.bean的生命周期：

1. 实例化（当我们加载beans.xml文件是），把我们的bean（前提是scope=singleton)实例化到内存。
2. 调用set()方法设置属性。
3. 如果实现了bean名字关注接口（BeanNameAware），则可以通过调用setBeanName方法获取id。
4. 如果你实现了bean工厂关注接口，则可以获取BeanFactory。
5. 如果你是实现了ApplicationContextAware则调用方法

public void setAplicationContext(ApplicationContext arg0)  throws BeansException{
.......
}

1. 如果bean和一个后置处理器关联，则会自动调用Object postProcessBeforeInitialization方法。
2. 如果实现了InitializingBean接口，则会调用afterPropertiesSet方法
3. 如果自己在则可以在bean中定义自己的初始化方法。
4. 如果bean和一个后置处理器关联，则会自动调用Object postProcessAfterInitialization方法。
5. 使用我们的Bean。
6. 容器关闭。
7. 可通过实现DisposableBean接口来调用destory方法。
8. 可以在调用定制的销毁方法。

小结：我们实际开发中往往没有这么多过程。常见的是：
1-->2-->6-->9-->10-->11

通过BeanFactory来获取bean对象，bean的生命周期是否和ApplicationContext一样。
答：不一样，1-->2-->-->3-->7-->8-->10-->11-->12--13.

4.配置bean

如何给集合类型注入值：

//Student.java
package com.student;
public class Student {
    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;
    }
}

//Major.java
package com.student;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Major {
    private String name;
    private List<Student> studentList;
    private Set<Student> studentSet; 
    private Map<String, Student> studentMap;
    public Set<Student> getStudentSet() {
        return studentSet;
    }
    public void setStudentSet(Set<Student> studentSet) {
        this.studentSet = studentSet;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<Student> getStudentList() {
        return studentList;
    }
    public void setStudentList(List<Student> studentList) {
        this.studentList = studentList;
    }
    public Map<String, Student> getStudentMap() {
        return studentMap;
    }
    public void setStudentMap(Map<String, Student> studentMap) {
        this.studentMap = studentMap;
    }
}

//Bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--
  - Middle tier application context definition for the image database.
  -->
<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:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
        <bean id="student_1" class="com.student.Student">
            <property name="name">
                <value>王二小</value>
            </property>
            <property name="age">
                <value>23</value>
            </property>
        </bean>
        <bean id="student_2" class="com.student.Student">
            <property name="name">
                <value>张三丰</value>
            </property>
            <property name="age">
                <value>43</value>
            </property>
        </bean>
        <!-- List list中可以有相同的对象 -->
        <bean id="majorList" class="com.student.Major">
            <property name="name">
                <value>数学系</value>
            </property>
            <property name="studentList">
                <list>
                    <ref bean="student_1"/>
                    <ref bean="student_2"/>
                </list>
            </property>
        </bean>
        <!-- Set set中不能有相同的对象-->
        <bean id="majorSet" class="com.student.Major">
            <property name="name">
                <value>中文系</value>
            </property>
            <property name="studentSet">
                <set>
                    <ref bean="student_1"/>
                    <ref bean="student_2"/>
                </set>
            </property>
        </bean>
        <!-- Map -->
        <bean id="majorMap" class="com.student.Major">
            <property name="name">
                <value>英文系</value>
            </property>
            <property name="studentMap">
                <map>
                    <entry key="2001" value-ref="student_1"/>
                    <entry key="2002" value-ref="student_2"/>
                </map>  
            </property>
        </bean>
</beans>

//Main测试函数
package com.student;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("com/student/Beans.xml");
        System.out.println("*************通过List取值**********");
        Major maList = (Major) ac.getBean("majorList");
        System.out.println("专业：" + maList.getName());
        for(Student stu: maList.getStudentList()){
            System.out.println(stu.getName()+ "  " + stu.getAge());
        }
        System.out.println("*************通过set取值**********");
        Major maSet = (Major) ac.getBean("majorSet");
        System.out.println("专业：" + maSet.getName());
        for(Student stu: maSet.getStudentSet()){
            System.out.println(stu.getName()+ "  " + stu.getAge());
        }
        System.out.println("*************通过Map取值**********");
        Major maMap = (Major) ac.getBean("majorMap");
        System.out.println("专业：" + maMap.getName());
        //迭代Map
        //1.迭代器
            Map<String, Student> stumap =  maMap.getStudentMap();
            Iterator it = stumap.keySet().iterator();
            while(it.hasNext()){
                String key =  (String)it.next();
                Student student = stumap.get(key);
                System.out.println(key + " " + student.getName() + " " + student.getAge());
            }
        //2.Entry
        for(Entry<String, Student> enMap:maMap.getStudentMap().entrySet() ){
            System.out.println(enMap.getKey() + " " +enMap.getValue().getName()+"  " + enMap.getValue().getAge());
        }
    }
}

内部bean使用方法：

<bean id="foo" class=".....Foo>
    <property name=" 属性">
        <!--第一种方法引用-->
        <ref bean="bean对象名">
        <!--内部bean-->
        <bean>
        <property>
        </property>
        </bean>
    </property>
</bean>

继承表示：

<bean id="foo" parent="父类对象名" class=".....Foo>
    <property name=" 属性" value="值"/>
</bean>

5.通过构造函数注入值

public class ExampleBean {
    private int years;
    private String ultimateAnswer;
    public ExampleBean(int years, String ultimateAnswer) {
        this.years = years;
        this.ultimateAnswer = ultimateAnswer;
    }
}

方法1.构造参数类型匹配

<bean id="exampleBean" class="examples.ExampleBean">
  <constructor-arg type="int" value="7500000"/>
  <constructor-arg type="java.lang.String" value="42"/>
</bean>

方法2.构造参数索引（通过使用索引属性不但可以解决多个简单属性的混淆问题，还可以解决有可能有相同类型的2个构造参数的混淆问题了，注意index是从0开始。

）

<bean id="exampleBean" class="examples.ExampleBean">
  <constructor-arg index="0" value="7500000"/>
  <constructor-arg index="1" value="42"/>
</bean>

6.自动装配

//Dog.java get/set方法略
private String name;
private int age;

//Master.java
private String name;
private Dog dog;

1. byname

<bean id="master" class="com.autowire.Master" autowire="byName">
        <property name="name" value="朱元璋"></property>
    </bean>
    <bean id="dog" class="com.autowire.Dog">
        <property name="name" value="小黄"/>
        <property name="age" value="2"/>
    </bean>

//测试
ApplicationContext ac = new ClassPathXmlApplicationContext("com/autowire/Beans.xml");
Master ma = (Master) ac.getBean("master");
        System.out.println(ma.getName() + "  " + ma.getDog().getName());

上面例子可以看出，并没有配置master中的dog属性，但是还是可以直接取出，这是因为配置了autowire="byName";

1. byType
   和byName类似，没有配置master中dog属性，但是如果是 autowire="byType",那么spring回首先在配置中去加载property配置，如果没有dog属性，再回在beans中寻找Dog类型的bean，如果有多个，会抛异常。

2. constructor
   其他和byName类似，但是在Master类中，必须有以Dog为参数的构造函数。

public Master(Dog dog) {
        this.dog = dog;
    }

4.autodetect

1. defualt
2. 这个需要在
   当你在指定了default-autowrite后，所有的bean的默认的autowire就是指定的装配方法
   如果没有在没有在这里指定，默认就是no。
3. no
   不自动装配

7. 启动注解

<context:annotation-config/>

该配置可以激活注解。

8.使用spring的特殊bean，完成分散配置。

//DBUtil.java
private String drivername;
private String url;
private String name;
private String password;

<!--Beans.xml-->
<!-- 引入db.properties-->
    <context:property-placeholder location="classpath:com/properties/db.properties"/>
    <bean id="dbutil" class="com.properties.DBUtil">
        <property name="name" value="${name}"/>
		<property name="drivername" value="${drivername}"/>
        <property name="url" value="${url}"/>
		<property name="password" value="${password}"/>
    </bean>

db.properties

name=root
drivername=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost/conn
password=1234

8. aop编程

1.aop说明

aop(aspect oriented programming)面向切面编程,是对一类对象或者所有对象编程。
核心是在不增加代码的基础上还增加功能。

2.实例说明

目标，在调用TestService的sayHello()方法之前进行日志书写。
步骤：

1. 定义接口

public interface TestServiceInter {
    public void sayHello();
}

2. 编写对象（被代理对象，即目标对象）

//set/get方法略
public class Test1Service implements TestServiceInter,TestServiceInter_2{
    private String name;
    @Override
    public void sayHello() {
        System.out.println("hello " + name);
        }
}

3. 编写通知（前置通知：目标方法调用前调用）

public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
    /**
     * paraMethod 调用的方法
     * paramArrayOfObject:给她方法传递的参数
     * paramObject：目标对象
     */
    @Override
    public void before(Method paramMethod, Object[] paramArrayOfObject, Object paramObject) 
            throws Throwable {
        System.out.println("记录日志...." + paramMethod.getName());
    }
}

4. 在beans.xml文件中配置

4.1 配置被代理对象
4.2 配置通知
4.3 配置代理对象，是ProxyFactoryBean的实例对象。
4.3.1 代理接口集
4.3.2 植入通知
4.3.3 配置被代理的对象

<!-- 配置被代理的对象 -->
    <bean id="test1Service" class="com.aop.Test1Service">
        <property name="name" value="朱元璋"></property>
    </bean>
    <!-- 配置前置通知 -->
    <bean id="MyMethodBeforeAdvice" class="com.aop.MyMethodBeforeAdvice"></bean>
    <!-- 配置代理对象 -->
    <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <!-- 配置代理接口集 -->
    <property name="proxyInterfaces">
        <list>  
            <value>com.aop.TestServiceInter</value>
        </list>
    </property>
    <!-- 把通知织入到代理对象 -->
    <property name="interceptorNames">
    <!-- 相当于把包MyMethodBeforeAdvice迁址通知和代理对象关联起来，我们
    也可以把通知看成拦截器 -->
        <value>MyMethodBeforeAdvice</value>
    </property>
    <!-- 配置被代理的对象，可以指定 -->
    <property name="target" ref="test1Service"/>
    </bean>

3.其他通知类型

（其他通知的使用方法和前置通知类似）
注：
环绕通知

public class MyMethodInterceptor implements MethodInterceptor {
    /**
     * @环绕通知
     */
    @Override
    public Object invoke(MethodInvocation paramMethodInvocation) throws Throwable {
        System.out.println("环绕通知：   方法调用之前");
        Object obj = paramMethodInvocation.proceed();//如果没有这句和返回切入的方法将不会被调用
        System.out.println("环绕通知：  方法调用之后");
        return obj;
    }
}

异常通知

public class MyThrowAdvice implements ThrowsAdvice {
    public void afterThrowing(Method m,Object[] os, Object targt,Exception e){
        System.out.println("出事了~~ " + e.getMessage());
    }
}   

自定义通知切入点

<!-- 配置前置通知切入点（值让某个特定的方法切入前置通知） 只让sayHello方法切入前置通知-->
    <bean id="MyMethodBeforeAdviceFilter" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
        <property name="advice" ref="MyMethodBeforeAdvice"></property>
        <property name="mappedNames">
            <list>
                <value>sayHello</value>
            </list>
        </property>
    </bean>

在将MyMethodBeforeAdviceFilter织入到代理对象中就可以了。

所有配置总览表：

<!-- 配置被代理的对象 -->
    <bean id="test1Service" class="com.aop.Test1Service">
        <property name="name" value="朱元璋"></property>
    </bean>
    <!-- 配置前置通知 -->
    <bean id="MyMethodBeforeAdvice" class="com.aop.MyMethodBeforeAdvice"></bean>
    <!-- 配置后置通知 -->
    <bean id="MyAfterReturningAdvice" class="com.aop.MyAfterReturningAdvice"></bean>
    <!-- 配置环绕通知 -->
    <bean id="MyMethodInterceptor" class="com.aop.MyMethodInterceptor"></bean>
    <!-- 配置异常通知 -->
    <bean id="MyThrowAdvice" class="com.aop.MyThrowAdvice"></bean>
    <!-- 配置前置通知切入点（值让某个特定的方法切入前置通知） -->
    <bean id="MyMethodBeforeAdviceFilter" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">
        <property name="advice" ref="MyMethodBeforeAdvice"></property>
        <property name="mappedNames">
            <list>
                <value>sayHello</value>
            </list>
        </property>
    </bean>
    <!-- 配置代理对象 -->
    <bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <!-- 配置代理接口集 -->
    <property name="proxyInterfaces">
        <list>  
            <value>com.aop.TestServiceInter</value>
            <value>com.aop.TestServiceInter_2</value>
        </list>
    </property>
    <!-- 把通知织入到代理对象 -->
    <property name="interceptorNames">
    <!-- 相当于把包MyMethodBeforeAdvice迁址通知和代理对象关联起来，我们
    也可以把通知看成拦截器 -->
        <list>
        <!-- 使用自定义前置通知的切入点 -->
        <value>MyMethodBeforeAdviceFilter</value>
        <!-- <value>MyMethodBeforeAdvice</value> -->
        <value>MyAfterReturningAdvice</value>
        <value>MyMethodInterceptor</value>
        <value>MyThrowAdvice</value>
        </list>
    </property>
    <!-- 配置被代理的对象，可以指定 -->
    <property name="target" ref="test1Service"/>
    </bean>

问：在spring的aop中，当你通过代理对象实现了接口aop接口的时候，获取的ProxyFactoryBean是什么类型？
答：返回的是一个代理对象，如果目标对象实现了接口，则spring使用jdk动态代理技术，如果目标对象没有实现接口， 则spring使用CGLIB技术。