Spring的使用

Spring的组成
1、    Core模块
该模块是Spring的核心容器，它实现了Ioc模式和Spring框架的基础功能。
2、    Context模块
该模块继承BeanFactory类，并添加了事件处理、国际化、资源加载、透明加载已经数据检验等功能。
3、    Aop模块
  Spring集成了所以Aop功能，通过事务管理可以任意Spring管理的对象Aop化。
4、    Dao模块
该模块提供了JDbc的抽象层，简化了数据库厂商的异常处理。
5、    Orm映射模块
该模块提供了对现有ORM框架支持，为Hibernate提供了完美的结合。
6、    web模块
该模块建立在SpringContext基础之上，提供了Servlet监视器的Context和web应用的上下文，为现有Web框架提供了集成。
7、    MVC模块
实现了控制逻辑和业务逻辑的清晰分离。

Spring的包
包名    说明
Org.springframework.aop-3.1.1.release.jar    Spring的Aop模块
Org.springframework.asm-3.1.1.release.jar    Spring独立的asm程序，需要asm.jar包
Org.springframework.aspects-3.1.1.release.jar    Spring提供对Aspectj框架的整合
Org.springframework.beans-3.1.1.release.jar    Ioc的实现
Org.springframework.context.support-3.1.1.release.jar    MVC扩展支持
Org.springframework.context-3.1.1.release.jar    Spring的上下文，spring提供在基础ioc功能上的扩展服务，此外还提供许多企业级服务的支持，如邮件服务器、任务调度、JNDI定位、Ejb集成等。
Org.springframework.core-3.1.1-release.jar    Spring的核心模块
Org.springframework.expreesion-3.1.1.release.jar    Spring的表达式语言
Org.springframework.instrument.tomcat-3.1.1.release.jar    tomcat连接池的支持
Org.springframework.instrument-3.1.1.release.jar    对服务器的代理接口
Org.springframework.jdbc-3.1.1.release.jar    jdbc模块
Org.springframework.jms-3.1.1.release.jar    JMS  API使用的简单封装
Org.springframework.orm-3.1.1-release.jar    Orm模块,支持Hibernate和JDO等orm工具
Org.springframework.oxm.3.1.1-release.jar    对Object/XML的映射支持
Org.springframework.test-3.1.1.release.jar    对Junit等测试框架的简单封装
Org.springframework.transaction-3.1.1.release.jar    jdbc、Hibernate、jdo、jpa等提供一致的声明式和编程式事务关联
Org.springframework.web.portlet-3.1.1.release.jar    Mvc的增强
Org.springframework.web.servlet-3.1.1.release.jar    对java EE6.0和Servlet3.0的支持
Org.springframework.web.struts-3.1.1.release.jar    整合struts
Org.springframework.web-3.1.1.release.jar    web模块，包含web application context
需要其他包的支持commons-logging.jar和aopalliance.jar的支持。
BeanFactory关联bean
BeanFactory采用了java的工厂模式，通过配置xml文件或属性文件.properties中读取javabean的定义来创建、配置和关联javaBean。BeanFactory有很多实现类，其中，xmlBeanFactory类通过xml文件格式读取配置信息加载javaBean。
//获取配置文件
Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件
            BeanFactory factory = new XmlBeanFactory(resource);
            User user = (User) factory.getBean("user");
bean的生命周期
    实例化javabean、初始化javaBean、使用javabean和销毁javaBean共4个阶段。

applicationContext接口的创建。
applicationContext接口有3个实现类：ClassPathXmlApplicationContext类、FileSystemXmlApplicationContext类、WebApplicationContext类。

1、    ClassPathXmlApplicationContext类创建
      ApplicationContext context=new ClassPathXmlApplicationContext(Sting configlocation);
通过参数指定spring的xml文件的位置来创建applicationContext容器。
2、FileSystemXmlApplicationContext类创建
     ApplicationContext context=new FileSystemXmlApplicationContext(Sting configlocation);
通过参数指定spring的xml文件的位置来创建applicationContext容器。
3、WebApplicationContext类创建
WebApplicationContext是spring的web容器，在Servlet中使用该类的方法有2种：一是在Servlet的web.xml文件中陪spring的ContextLoaderListener监听器；而是修改web.xml文件，在其中添加一个Servlet，定义使用spring的org.springframework.web.context.ContextLoaderServlet类。

依赖注入
1、    接口注入，Spring不支持。
2、    Setter注入，通过javaBean的setter方法为属性赋值，广泛应用。
3、    构造器注入，javaBean的有参构造方法给属性赋值。
Seter注入实例
User类
package com.User;

public class User {

    private Integer id;
    private String name;
    private String age;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }

}

在ApplicationContext.xml配置文件里添加Bean
<?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-3.0.xsd">
    <!-- User实体 -->
    <bean name="user" class="com.User.User">
    <property name="id"><value>1</value></property>
    <property name="name"><value>小明</value></property>
    <property name="age"><value>15</value></property>
    </bean>

    </beans>
使用Manager类的main方法测试setter注入
public static void main(String[] args) {
        // TODO Auto-generated method stub
        //加载配置文件
        Resource resource=new ClassPathResource("applicationContext.xml");
        //初始化beanFactory
        BeanFactory factory=new XmlBeanFactory(resource);
        //获取Bean
        User user=(User)factory.getBean("user");
        //输出bean信息
        System.out.println(user.getId());
        System.out.println(user.getName());
        System.out.println(user.getAge());

    }
使用构造器注入
User类
package com.User;

public class User {

    private Integer id;
    private String name;
    private String age;
    //构造方法
    public User(Integer id,String name,String age){
        this.id=id;
        this.name=name;
        this.age=age;

    }
    //值输出方法
    public void printinfo(){
        System.out.println(id);
        System.out.println(name);
        System.out.println(age);

    }

}
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-3.0.xsd">
    <!-- User实体 -->
    <bean name="user" class="com.User.User">
    <!-- 构造器注入，要使用标签<constructor-arg> -->
    <constructor-arg><value>1</value></constructor-arg>
    <constructor-arg><value>小明</value></constructor-arg>
    <constructor-arg><value>15</value></constructor-arg>
    </bean>

    </beans>
Manager类的main测试方法
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //加载配置文件
        Resource resource=new ClassPathResource("applicationContext.xml");
        //初始化beanFactory
        BeanFactory factory=new XmlBeanFactory(resource);
        //获取Bean
        User user=(User)factory.getBean("user");
        //输出bean信息
        user.printinfo();

    }
引用其他Bean
User类
package com.US;

public class User {

    private Integer id;
    private String name;
    private String age;
…//省略setter和getter方法
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-3.0.xsd">

     <!-- 注册User类到bean -->
     <bean id="user" class="com.US.User">
     <property name="id"><value>1</value></property>
     <property name="name"><value>xiaoming</value></property>
     <property name="age"><value>14</value></property>
     </bean>

    <!-- 注入javaBean -->
    <bean name="/main.do" class="com.US.Manager">
    <property name="user">
    <ref local="user"/>
    </property>
    </bean>

    </beans>
Manager类
package com.US;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

//Manager继承Spring的AbstracController的控制器；AbstractController在web.servlet.mvc的jar包里
public class Manager extends AbstractController {
    //引入User类作属性，通过Spring注入到对象user
    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
    //实现handleRequestInternal抽象方法用来实在自己的业务逻辑
    protected ModelAndView handleRequestInternal(
            HttpServletRequest arg0,HttpServletResponse arg1) throws Exception{

        user.printinfo();//执行user的输出方法

        return null;

    }

}
Spring的配置文件ApplicationContext.xml要放到Web-Inf文件夹下，保证web.xml文件引用是可以找的到。项目启动时Spring自动加载ApplicationContext.xml文件配置信息。
Web.xml配置ApplicationContext.xml文件
<!-- 通过Servlet配置Spring的自动加载文件 -->
  <servlet>
  <servlet-name>dispatcherServlet</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/applicationContext.xml</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
  <servlet-name>dispatcherServlet</servlet-name>
  <url-pattern>*.do</url-pattern>
  </servlet-mapping>
创建匿名内部JavaBean
    <!-- 创建匿名JavaBean -->
    <bean id="school" class="School">
    <property name="user">
    <bean class="com.US.User"/>
    </property>
    </bean>

Spring Aop
Aop术语
1、切面(aspect)
切面就是程序中的一段段互不相干的代码。
2、连接点(join Point)
连接点是指对象的一个操作，比如对象调用一个方法，或对象某个方法抛出异常等。
3、切入点(Pointuct)
切入点就是连接点的集合，可以理解为一段程序流中对象多个连接点的集合，也就是对象调用了多个方法，或抛出多个异常。
4、通知(advice)
通知就是在切入点处告诉程序要执行切面的业务逻辑。
5、目标对象(target)
被通知的对象就叫目标对象。也可以理解为被代理的对象。目标对象作业务处理。
6、织入(weaving)
织入是将切面功能应用到目标对象的过程，有代理工厂创建一个代理对象，代理对象可以为目标对象执行切面功能。
3种织入方式：编译时期（complie time）织入、类加载时期（Classlocad  time）织入、执行时期（runtime）织入。最常用的是执行时期织入。
9、引入(introduction)
对一个已编译的类（Class），在运行时期动态向其中加载属性和方法。

Spring的切入点
切入点的3种类型：静态切入点、动态切入点和自定义切入点。
静态切入点可以为对象的方法签名，对象调用对象的方法时，这个方法就是静态切入点。静态切入点需要在配置文件中指定。
<bean id=”pointAdvisor” class=”org.springframework.aop.support.RegexpMethodPointAdvisor”>
<property name=”advice”>
<ref bean=”MyAdvisor”/><!—指定通知-->
</property>
<property name=”patterns”>
<list>
<value>.*getConn*.</value><!—指定所以以getConn开头的方法都是切入点-->
<value>.*closeConn*.</value>
</list>
</property>
</bean>
由于静态切入点只在代理创建是执行一次，然后缓存结果。下一次调用时直接从缓存中读取即可，所以在性能上要远高于动态切入点。
但是当需要通知的目标对象的类型多于一种，而且需要织入的方法很多时，用静态切入点编程会很烦琐，并且不够灵活且会降低性能，这时可以选用动态切入点。

动态切入点
动态切入点可应用在相对变化的位置，如方法的参数上。由于程序运行过程中的传递的参数变化，切入点也随这变化，它会根据不同的参数来织入不同的切面。
深入静态切入点
静态切入点在某个方法名上织入切面，所以在织入程序代码前要匹配方法名，判断当前正在调用的方法是不是已经定义的静态切入点。匹配成功并织入切面；配置失败不织入切面。匹配的过程是有Spring自动实现，不需要编程的干预。
Spring中的其他切入点
切入点的实现类    说明
Org.springframework.support.JdkRegexpMethodPointcut    JDK正则表达式方法切入点
Org.springframework.support.NameMatchMethodPointcut    名称匹配器方法切入点
Org.springframework.support.StaticMatchMethodPointcut    静态方法匹配器切入点
Org.springframework.support.ControlFlowPointcut    流程切入点
Org.springframework.support.DynamicMethodMatcherPointcut    动态方法切入点

Spring持久化
Dao模式：Dao属于O/R Mapping技术的一种，通过O/R技术实现与RDBMS（关系数据库管理系统）的交互。
Spring的Dao理念
SpringDao框架存取数据时，通过一个数据存取接口来操作。
创建User类

public class User {

    private Integer id;
    private String name;
    private String age;
…//省略setter和getter
UserDaoimpl接口
public interface UserDaoimpl {
    public void inserUser(User user);//添加用户信息
}
UserDao实现

import java.sql.Connection;
import java.sql.Statement;

import javax.sql.DataSource;

public class UserDao implements UserDaoimpl {
    private DataSource datasource;

    public DataSource getDatasource() {
        return datasource;
    }

    public void setDatasource(DataSource datasource) {
        this.datasource = datasource;
    }

    //添加数据
    public void inserUser(User user){
        int id=user.getId();
        String name=user.getName();
        String age=user.getAge();

        Connection con=null;
        Statement st=null;
        try{
            con=datasource.getConnection();
            st=con.createStatement();
            st.execute("insert into tb_user(id,name,age) values ('"+id+"','"+name+"','"+age+"')");
            st.close();
            con.close();
        }catch(Exception e){
            e.printStackTrace();
        }

    }

}

applicationContext.xml配置信息
    <!-- 配置数据源 -->
 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <property name="driverClassName">
 <value>oracle.jdbc.driver.OracleDriver</value>
 </property>
 <property name="url">
 <value>jdbc:oracle:thin:@127.0.0.1:1521:orcl</value>
 </property>
 <property name="username">
 <value>system</value>
 </property>
 <property name="password">
 <value>guoyanan</value>
 </property>
 </bean>

 <!-- 注入UserDao注入数据 -->
 <bean id="userDao" class="com.US.UserDao">
 <property name="datasource" >
 <ref local="dataSource"/>
 </property>
 </bean>
Main方法执行
public static void main(String[] args){
         Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件
            BeanFactory factory = new XmlBeanFactory(resource);

        User user=new User();
        user.setId(3);
        user.setName("xxx");
        user.setAge("12");

        UserDao userDAO = (UserDao) factory.getBean("userDao");//获取UserDAO
            userDAO.inserUser(user);//执行添加方法

        System.out.println("OK");

    }

事务管理
事务管理在应用程序中至关重要，它是一系列任务组的工作单元，其中的所有任务 必须同时执行。执行结果：全部成功和全部失败。
1、编程式事务管理
Sping中主要有2中编程式事务管理实现方法，分别通过使用Plaform  Transaction  Manager接口的事务管理器或Transaction  Template实现。推荐使用Transaction  Template实现方式，符合Spring的模版模式。
在Spring配置文件中声明事务管理器和TransactionTemplate。
<!-- 配置数据源 -->
 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <property name="driverClassName">
 <value>oracle.jdbc.driver.OracleDriver</value>
 </property>
 <property name="url">
 <value>jdbc:oracle:thin:@127.0.0.1:1521:orcl</value>
 </property>
 <property name="username">
 <value>system</value>
 </property>
 <property name="password">
 <value>guoyanan</value>
 </property>
 </bean>

    <!-- 定义TransactionTemplate模版 -->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
    <property name="transactionManager">
    <ref bean="transactionManager"/>
    </property>
    <property name="propagationBehaviorName">
    <!-- 限定事务的传播行为，规定当前方法必须运行在事务中，
    如果没有事务，则创建一个。一个新的事务和方法同时开始，
    随这方法返回或抛出异常终止。 -->
    <value>PROPAGATION_REQUIRED</value>
    </property>
    </bean>
    <!-- 定义事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource">
    <ref bean="dataSource"/>
    </property>
    </bean>
    <!-- 注入事务管理器 -->
    <bean id="transactionExample" class="com.US.TranscationExample">
    <property name="dataSource">
    <ref bean="dataSource"/>
    </property>
    <property name="transactionManager">
    <ref bean="transactionManager"/>
    </property>
    <property name="transactionTemplate">
    <ref bean="transactionTemplate"/>
    </property>

    </bean>
创建类transactionExample。
public class TranscationExample {
    //注入数据源
    DataSource dataSource;
    //注入事务管理器
    PlatformTransactionManager  transactionManager;
    //注入事务管理模版
    TransactionTemplate  transactionTemplate;
    public DataSource getDataSource() {
        return dataSource;
    }
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    public PlatformTransactionManager getTransactionManager() {
        return transactionManager;
    }
    public void setTransactionManager(PlatformTransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }
    public TransactionTemplate getTransactionTemplate() {
        return transactionTemplate;
    }
    public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
        this.transactionTemplate = transactionTemplate;
    }

   public void transactionOpen(){
       transactionTemplate.execute(new TransactionCallback(){

        @Override
        public Object doInTransaction(TransactionStatus arg0) {
            // TODO Auto-generated method stub
            //获取数据库链接
            Connection con=DataSourceUtils.getConnection(dataSource);
            try{
                Statement st=con.createStatement();

                st.execute("insert into tb_user (id,name,age) values('5','jj','14')");

            }catch(Exception e){
                transactionManager.rollback(arg0);
                System.out.println("插入操作执行失败");
                e.printStackTrace();
            }

            return null;
        }
       });

   }

}
Manager类测试
Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件
            BeanFactory factory = new XmlBeanFactory(resource);

            TranscationExample  trans=(TranscationExample)factory.getBean("transactionExample");

            trans.transactionOpen();
声明式事务管理
在Spring中常用TransactionProxyFactoryBean完成声明式事务管理。
<?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-3.0.xsd">

     <!-- 配置数据源 -->
 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <property name="driverClassName">
 <value>oracle.jdbc.driver.OracleDriver</value>
 </property>
 <property name="url">
 <value>jdbc:oracle:thin:@127.0.0.1:1521:orcl</value>
 </property>
 <property name="username">
 <value>system</value>
 </property>
 <property name="password">
 <value>guoyanan</value>
 </property>
 </bean>

    <!-- 定义事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource">
    <ref bean="dataSource"/>
    </property>
    </bean>

    <!-- 定义TransactionProxy -->
    <bean id="transactionProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager">
    <ref local="transactionManager"/>
    </property>
    <property name="target">
    <!-- 以内部类的形式指定代理对象 -->
    <bean id="UserDao" class="com.US.UserDao">
    <property name="dataSource">
    <ref local="dataSource"/>
    </property>
    </bean>
    </property>
    <property name="proxyTargetClass" value="true"/>
    <property name="transactionAttributes">
    <props>
    <!-- 通过正则表达式匹配事务性方法，并指定方法的事务属性，即代理
    对象中只要是以add开头的方法名必须运行在事务中 -->
    <prop key="inser*">PROPAGATION_REQUIRED</prop>
    </props>
    </property>
    </bean>

    </beans>
UserDao类代理对象
public class UserDao extends JdbcDaoSupport {
    //添加数据
    public void inserUser(User user){
        //执行添加的sql语句
            String sql="insert into tb_user(id,name,age) values ('"+user.getId()+"','"+user.getName()+"','"+user.getAge()+"')";

            //执行添加方法
            getJdbcTemplate().execute(sql);

    }

}
Manager类的main执行方法
public static void main(String[] args){
         Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件
            BeanFactory factory = new XmlBeanFactory(resource);

            UserDao  userdao=(UserDao)factory.getBean("transactionProxy");

            User user=new User();
            user.setId(7);
            user.setName("ll");
            user.setAge("17");
            //执行添加方法
            userdao.inserUser(user);

        System.out.println("OK");

    }
应用jdbcTemplate操作数据库
JdbcTemplate类是Spring的核心类之一，可以在org.springframework.jdbc.core包中找到。该类在内部已经处理了数据库资源的建立和释放，避免一些常见的错误。
JdbcTemplate中常用的数据查询方法
方法名称    说明
Int  QueryForInt(String sql)    返回查询的数量
Int  QueryForInt(String sql,Object[]  args)
Long QueryForLong(String sql)    返回查询信息的数量
Long QueryForLong(String sql,Object[] args)
Object  QueryForObject(String sql,Class  type)    返回满足条件的查询对象
Object  QueryForObject(String sql,Class  type,object args)
List  QueryForList(String sql)    返回对象List集合
List  QueryForList(String sql,Object[] args)    

配置JdbcTemplate和数据源
    <!-- 配置数据源 -->
 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
 <property name="driverClassName">
 <value>oracle.jdbc.driver.OracleDriver</value>
 </property>
 <property name="url">
 <value>jdbc:oracle:thin:@127.0.0.1:1521:orcl</value>
 </property>
 <property name="username">
 <value>system</value>
 </property>
 <property name="password">
 <value>guoyanan</value>
 </property>
 </bean>

    <!-- 配置jdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource">
    <ref local="dataSource"/>
    </property>
     </bean>
Main测试方法
Resource resource = new ClassPathResource("applicationContext.xml");            //装载配置文件
            BeanFactory factory = new XmlBeanFactory(resource);

            JdbcTemplate  jdbc=(JdbcTemplate)factory.getBean("jdbcTemplate");
            jdbc.update("insert into tb_user (id,name,age) values('8','jj','14')");