spring4介绍

历史
    2002年，Rod Johnson写了一本书，对以EJB为核心的Java EE平台进行批评和思考。
    2003年，Rod Johnson开发了一个框架，这就是Spring。Spring的很多设计理念，其实就是起源EJB的启发。
    当然，Spring更加简单易用。
项目中间层
    ssh: Spring Struts2 Hibernate/ssm: Spring SpringMVC MyBatis
    Spring(没有代替框架)
下载
    官方网站
        http://www.springsource.org
    下载仓库地址
        http://repo.springsource.org/libs-release-local/org/springframework/spring/
    maven
        搜索spring即可
目录介绍
    docs 
        api文档与开发指南
    libs 
        所有模块的jar包
    schema 
        xml的约束文件
使用步骤
    1.拷贝jar (20个) + common-logging-xx.jar
        libs下的jar包
    2.写appContext.xml配置文件
        docs\spring-framework-reference\index.html\Core\Configuration metadata
        拷贝xml基础配置
    3.获取Spring容器
        ClassPathXmlApplicationContext (class路径下找配置文件)
        FileSystemXmlApplicationContext (磁盘目录下找配置文件)
    4.到Spring容器中获取bean
    5.关闭Spring容器
注意
    spring4使用jdk7
    spring5使用jdk8
得到spring容器两种方式
    第一种方式
        src/appContext.xml
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("appContext.xml");
        User user = (User)context.getBean("user");
        context.close();
    第二种方式
        src/appContext.xml
        //FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("D:\\myselfwork1\\SpringTest\\src\\appContext.xml");
        FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("classpath:appContext.xml");
        User user = (User)context.getBean("user");
        System.out.println(user);
        context.close();

spring配置详解

beans
    根元素,配置全局属性
    对所有的bean子元素起作用
    属性
        default-lazy-init 否默认延迟初始化bean
bean
    驱动类的构造器创建实例
    指定自己的相关的属性
    属性
        id 唯一标识符
        class 指定类(包名+类名)
        lazy-init 延迟初始化
        abstract 抽象类,true:Spring容器不会初始化,可以不用写class属性
    子标签
        constructor-arg 指定构造器中的参数(有参数的构造器)
        property 驱动setter方法设置参数
        constructor-arg说明
            <bean id="user" class="com.shuai.domain.User"></bean>
                调用的是无参构造public User() {}
            <bean id="user" class="com.shuai.domain.User">
                <constructor-arg><value type="java.lang.String">帅哥</value></constructor-arg>
            </bean>
                调用的是有参构造public User(String name) {}
            <bean id="user" class="com.shuai.domain.User">
                <constructor-arg><value type="java.lang.String">帅哥</value></constructor-arg>
                <constructor-arg><value type="int">20</value></constructor-arg>
            </bean>
                调用的是有参构造public User(String name, int age) {}
        property说明
            <bean id="user" class="com.shuai.domain.User">
                <property name="name"><value type="java.lang.String">帅哥</value></property>
            </bean>
                调用的是setter方法public void setName(String name) {}

IOC(控制反转) 与 DI(依赖注入)重点

IOC
    Inversion of Control
    控制反转
    对象的创建交给Spring去做.
    B类需要一个A类对象,按照惯例B类自己new一个A类对象.由B来控制A是否被创建.但是现在对象的创建交给Spring做了,那么控制关系就反过来了,称为控制反转.
DI
    Dependecy Injection
    依赖注入
    B类需要一个A类对象,只能接受Spring容器的注入.
    从容器角度来看,容器将A对象注入到B类中,就称为依赖注入

依赖注入各种类型constructor-arg/property

constructor-arg属性
    value 可以传入8种基本数据类型/基本数据类型包装类/字符串
    ref 引用容器中的bean实例
    type 数据类型
    index 在构造函数中的位置
    name 构造函数中的名字
value标签
    8种基本数据类型(byte/short/int/long/float/double/char/boolean)
        <value type="byte">1</value>
        public User(byte b) {}
    基本数据类型包装类(Byte,Short,Integer,Long,Float,Double,Character,Boolean)
        <value type="java.lang.Byte">1</value>
        public User(Byte b) {}
    字符串(String)
        <value type="java.lang.String">帅哥</value>
        public User(String b) {}
array标签
    value-type 数据类型 默认是String类型
        <array value-type="java.lang.String">
            <value>aa</value><value>bb</value>
        </array>
        public User(String[] arr) {}
list标签
    value-type 数据类型 默认是String类型
        <list value-type="java.lang.String">
            <value>a</value><value>10</value>
        </list>
        public User(List<String> list) {}
set标签
    value-type 数据类型 默认是String类型
        <set value-type="java.lang.String">
            <value>aa</value><value>bb</value>
        </set>
        public User(Set<String> set) {}
map标签
    value-type 数据类型 默认是String类型
        <map><entry key="aa" value="bb"></entry></map>
        public User(Map<String,String> map) {}
props标签
    value-type 数据类型 默认是String类型
        <props><prop key="url">xx</prop></props>
        public User(Properties prop) {}
bean标签
    <bean class="java.util.Date"/>
    public User(Date date) {}
ref标签
    引用容器中的bean实例
    <bean id="date" class="java.util.Date"/>
    <ref bean="date"/>
    public User(Date date) {}
idref标签
    引用bean的id是一个字符串
    public User(Date date) {}

配置别名

第一种方式
    <bean id="user" name="user2,user3" class=""/>
    <bean id="user" name="user2 user3" class=""/>
第二种方式
    <bean id="user" class=""/>
    <alias name="user" alias="user1"/>

导入其它配置文件

src/appContext-service.xml
<import resource="appContext-service.xml"/>

bean的作用域

singleton
    单例
    Spring容器中的实例都默认单例
prototype
    不会预初始化,每次都会创建一个新实例
request
    对应Web应用request作用域
session
    对应Web应用session作用域
application
    对应Web应用application作用域
websocket
    Scopes a single bean definition to the lifecycle of a WebSocket. Only valid in the context of a web-aware Spring ApplicationContext
globalSession
    Scopes a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a Portlet context. Only valid in the context of a web-aware Spring ApplicationContext.

bean中获取Spring容器

public class User implements ApplicationContextAware{
    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {}
}

p调用属性set方法赋值命名空间

在配置文件中增加一行 xmlns:p="http://www.springframework.org/schema/p"
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p="http://www.springframework.org/schema/p"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd">
        <bean id="date" class="java.util.Date"/>
        <bean id="user" class="com.shuai.domain.User" 
            p:name="shuaige"
            p:date-ref="date"></bean>
    </beans>
    public class User{
        private String name;
        private Date date;
        getter/setter..
    }
注意：
    p:set方法名去掉前面的set后首字母小写=值(标量类型)

自动装配(bean的autowire属性)??????

说明
    autowire 自动装配(有4种装配方式)
    autowire-candidate 是否作为自动装配的候选者
byName
    按名称自动装配
    <bean id="idCard" class="com.shuai.domain.IdCard"/>    
    <bean id="user" class="com.shuai.domain.User" autowire="byName"/>
    public class User{
        private IdCard idCard;
        getter/setter..
    }
byType
    按类型自动装配
    <bean id="idCard" class="com.shuai.domain.IdCard" autowire-candidate="true"/>    
    <bean id="user" class="com.shuai.domain.User" autowire="byType"/>
    public class User{
        private IdCard idCard;
        getter/setter..
    }
constructor
    按构造器自动装配,按照构造器中的形参的名字来选择bean的id名
    <bean id="idCard" class="com.shuai.domain.IdCard" autowire-candidate="true"/> 
    <bean id="user" class="com.shuai.domain.User" autowire="constructor"/>
    public class User{
        private IdCard idCard;
        public User(IdCard idCard) {
            this.idCard = idCard;
        }
    }
no
    不自动装配
default

c调用构造器赋值属性命名空间

在配置文件中增加一行 xmlns:c="http://www.springframework.org/schema/c"
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:c="http://www.springframework.org/schema/c"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd">
        <bean id="date" class="java.util.Date"/>
        <bean id="user" class="com.shuai.domain.User" 
            c:_0="帅哥"
            c:_1-ref="date"></bean>
    </beans>
    public class User{
        private String name;
        private Date date;
        public User(String name,Date date){}
    }
注意：
    p:set方法名去掉前面的set后首字母小写=值(标量类型)

Bean创建的三种方式

第一种方式
    构造器方式
    <bean id="user" class="com.shuai.domain.User"></bean>
第二种方式
    调用静态工厂方法创建Bean
    <bean id="user" class="com.shuai.domain.UserFactory" factory-method="createUser"></bean>
    public class UserFactory {
        public static User createUser(){
            return new User();
        }
    }
第三种方式
    调用实例工厂方法创建Bean
    <bean id="userFactory" class="com.shuai.domain.UserFactory"></bean>
    <bean id="user" factory-bean="userFactory" factory-method="createUser"></bean>
    public class UserFactory {
        public User createUser(){
            return new User();
        }
    }

继承配置

配置文件
    <bean id="human" abstract="true" p:name="shuaige"></bean>
    <bean id="user" class="com.shuai.domain.User" parent="human"></bean>
User.java
    public class User{
        private String name;
        getter/setter..
    }
注意:
    1.会自动给User类的name属性赋值,因为父类不存在
    2.父类Bean必须是一个抽象的Bean

Bean的生命周期

第一种方式
    init-method 属性
        初始化方法,创建对象时,会主动调用此方法
        <bean id="user" class="" init-method="init"/>
        public void init(){}
    destroy-method 属性
        销毁方法,在对象销毁之前会执行此方法
        <bean id="user" class=""destroy-method="destroy"/>
        public void destroy(){}
第二种方式
    InitializingBean 接口
        初始化接口
        创建对象时,会主动调用此接口的方法
        public class User implements InitializingBean{
            @Override
            public void afterPropertiesSet() throws Exception {}
        }
    DisposableBean 接口
        销毁接口,在对象销毁之前会执行此接口的方法
        public class User implements DisposableBean{
            @Override
            public void destroy() throws Exception {}
        }

调用get方法(PropertyPathFactoryBean)

配置
    <bean id="user" class="com.shuai.domain.User" p:name="帅哥" p:age="20"></bean>
    <bean id="getUsername" class="org.springframework.beans.factory.config.PropertyPathFactoryBean" p:targetObject-ref="user" p:propertyPath="name"/>
    <bean id="getUserage" class="org.springframework.beans.factory.config.PropertyPathFactoryBean" p:targetBeanName="user" p:propertyPath="age"/>
User.java
    public class User{
        private String name;
        get/set..
    }
获取
    String name = (String)context.getBean("getUsername");
    Integer age = (Integer)context.getBean("getUserage");

调用普通方法(MethodInvokingFactoryBean)

调用无参无返回值方法
    <bean id="invokeSay" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean" p:targetObject-ref="user" p:targetMethod="say"/>
调用有参无返回值方法
    <bean id="invokeSayWord" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean" p:targetObject-ref="user" p:targetMethod="sayword">
        <property name="arguments"><value>hi</value></property>
    </bean>
    注意:
        1.arguments是固定的,相当于一个数组,对应方法的形参列表
        2.传值要按照顺序去传即可
调用无参又返回值
    <bean id="invokeSay" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean" p:targetObject-ref="user" p:targetMethod="say"/>
    String backStr = (String)context.getBean("invokeSay");

调用静态方法(MethodInvokingFactoryBean)

调用无参无返回值静态方法
    <bean id="invokeHi" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean" p:targetClass="com.shuai.domain.User" p:targetMethod="hi"/>
    <bean id="invokeHi" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean" p:staticMethod="com.shuai.domain.User.hi"/>
带参数的同上调用普通方法

获取类中公共的静态常量(FieldRetrievingFactoryBean)

配置
    <bean id="table" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" p:staticField="com.shuai.domain.User.TABLE"/>
    <bean id="table" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" p:targetClass="com.shuai.domain.User" p:targetField="TABLE"/>
User.java
    public class User{
        public static final String TABLE = "user";
    }
调用
    String table = (String)context.getBean("table");

获取对象的属性(FieldRetrievingFactoryBean)

配置
    <bean id="user" class="com.shuai.domain.User" p:name="帅哥"></bean>
    <bean id="username" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" p:targetObject-ref="user" p:targetField="name"/>
User.java
    public class User{
        public String name;
    }
获取
    String name = (String)context.getBean("username");
注意:
    用的很少,会破坏我们的封装,不匹配POJO原则

util命名空间

说明
    IOC配置方式简化
    基于Schema简化
    引入
        添加xmlns:util="http://www.springframework.org/schema/util" ,并且引入spring-util-4.2.xsd文件
    标签
        util:constant 简化访问静态的Field
        util:property-path 简化get方法调用
        util:list 配置List集合
        util:set 配置Set集合
        util:map 配置Map集合
        util:properties 配置Properties集合
引入
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
                        http://www.springframework.org/schema/util
                        http://www.springframework.org/schema/util/spring-util-4.2.xsd"></beans>
util:constant
    <util:constant id="table" static-field="com.shuai.domain.User.TABLE"/>
    String table = (String)context.getBean("table");
util:property-path
    <bean id="user" class="com.shuai.domain.User" p:name="帅哥"></bean>
    <util:property-path id="name" path="user.name"/>
    String name = (String)context.getBean("name");
util:list
    <util:list id="list">
        <value>11</value>
        <value>22</value>
    </util:list>
    <bean id="user" class="com.shuai.domain.User" c:_0-ref="list"></bean>
    public class User {
        private List<String> list;
        public User(List<String> list) {}
    }
util:set
    <bean id="user" class="com.shuai.domain.User" c:_0-ref="set"></bean>
    <util:set id="set">
        <value>11</value>
        <value>22</value>
    </util:set>
    public class User {
        private Set<String> set;
        public User(Set<String> set) {}
    }
util:map
    <bean id="user" class="com.shuai.domain.User" c:_0-ref="map"></bean>
    <util:map id="map">
        <entry key="name" value="帅哥"></entry>
        <entry key="age" value="20"></entry>
    </util:map>
    public class User {
        private Map<String,String> map;
        public User(Map<String,String> map) {}
    }
util:properties
    <bean id="user" class="com.shuai.domain.User" c:_0-ref="prop"></bean>
    <util:properties id="prop">
        <prop key="username">root</prop>
        <prop key="password">root</prop>
    </util:properties>
    public class User {
        private Properties prop;
        public User(Properties prop) {}
    }

SpEL表达式

概述
    Spring Expression Language
    Spring表达式语言
    API
        ExpressionParser
            Spring表达式解析器 
        EvaluationContext
            Spring容器
运算表达式
    ExpressionParser parser = new SpelExpressionParser();
    //表达式
    String str = "10+10";
    //解析表达式
    Expression expression = parser.parseExpression(str);
    //得到结果
    Object value = expression.getValue();
    int value1 = expression.getValue(Integer.class);
字符串
    String str = parser.parseExpression("Spring").getValue(String.class);
字符串长度
    Object strlength = parser.parseExpression("'Spring'.bytes.length").getValue();
定义数组
    String[] arr = (String[])parser.parseExpression("new String[]{'Spring','mybatis'}").getValue();
定义List集合
    List<Object> list = (List<Object>)parser.parseExpression("{'spring',100}").getValue();
定义Map集合
    Map<Object,Object> map = (Map<Object,Object>)parser.parseExpression("{'1':'shuaige,'2':20}").getValue();
调用类的静态方法
    parser.parseExpression("T(java.lang.Math).random()").getValue();
    parser.parseExpression("T(java.lang.System).out.println('shuaige')").getValue();
创建类的对象,并且放入容器
    ExpressionParser parser = new SpelExpressionParser();
    EvaluationContext context = new StandardEvaluationContext();
    Object date = parser.parseExpression("new java.util.Date()").getValue();
    context.setVariable("date", date);
    Object longTime = parser.parseExpression("date.getTime()").getValue(context);
集合内数据操作
    迭代
        ExpressionParser parser = new SpelExpressionParser();
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("list", parser.parseExpression("{'SpringMvc','Spring','Hibernate'}").getValue());
        parser.parseExpression("list.?[length()>6]").getValue(context);
    字符串长度
        ExpressionParser parser = new SpelExpressionParser();
        EvaluationContext context = new StandardEvaluationContext();
        context.setVariable("list", parser.parseExpression("{'SpringMvc','Spring','Hibernate'}").getValue());
        parser.parseExpression("#list.![length()]").getValue(context);
配置文件中使用
    List集合
        <bean id="user" class="com.shuai.domain.User" p:list="#{{'springmvc','spring'}}" />
    set集合
        <bean id="user" class="com.shuai.domain.User" p:set="#{{20,30}}" />
    map集合
        <bean id="user" class="com.shuai.domain.User" p:map="#{{'name':'帅哥','age':20}}" />
    properties
        <bean id="user" class="com.shuai.domain.User" p:prop="#{{'city':'广州','name':'帅哥'}}" />
    数组
        <bean id="user" class="com.shuai.domain.User" p:arr="#{new String[]{'spring','hibernate'}}" />
    对象
        <bean id="user" class="com.shuai.domain.User" p:date="#{new java.util.Date()}" />
    调用静态方法赋值
        <bean id="user" class="com.shuai.domain.User" p:result="#{T(com.shuai.domain.ResultUtil).sum(10,20)}" />

Spring资源访问

第一种方式:配置文件
    单个文件
        文件
            src/db.properties
        配置
            <bean id="user" class="com.shuai.domain.User" p:resource="classpath:db.properties"/>
        User.java
            public class User {
                private Resource resource;
                get/set..
            }
    多个文件
        文件
            src/db.properties 和 src/log.properties
        配置
            <bean id="user" class="com.shuai.domain.User" p:resources="#{new Object[]{'classpath:db.properties','classpath:log.properties'}}"/>
        User.java
            public class User {
                private Resource[] resources;
            }
第二种方式:代码
    文件
        src/db.properties
    代码
        Resource resource = new ClassPathResource("db.properties");
        Resource resource = new FileSystemResource("D:\\workspace\\SpringTest\\src\\db.properties");

加载配置文件

属性占位符#{}
    第一种方式(PropertySourcesPlaceholderConfigurer):
        文件
            src/db.properties(name=root)
        配置
            <bean class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer" p:location="classpath:db.properties"></bean>
            <bean id="user" class="com.shuai.domain.User" p:name="${name}"></bean>
        User.java
            public class User {
                private String name;
                get/set..
            }
        多文件配置
            <bean class="org.springframework.context.support.PropertySourcesPlaceholderConfigurer" p:locations="#{new Object[]{'classpath:db.properties','classpath:log.properties'}}"/>
    第二种方式(配置)
        配置中添加一行 xmlns:context="http://www.springframework.org/schema/context"
            <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"
                xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
                    http://www.springframework.org/schema/context
                    http://www.springframework.org/schema/context/spring-context-4.2.xsd"></beans>
        使用标签
            <context:property-placeholder location="classpath:log.properties"/>
            <context:property-placeholder location="classpath:db.properties,classpath:log.properties"/>
属性重写
    第一种方式
        文件
            src/db.properties(user.name=root)
        配置
            <bean class="org.springframework.beans.factory.config.PropertyOverrideConfigurer" p:location="classpath:db.properties"></bean>
        User.java
            public class User {
                private String name;
                get/set..
            }
        多文件配置
            <bean class="org.springframework.beans.factory.config.PropertyOverrideConfigurer" p:locations="#{new Object[]{'classpath:db.properties','classpath:log.properties'}}"></bean>
    第二种方式
        配置中添加一行 xmlns:context="http://www.springframework.org/schema/context"
            <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"
                xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans.xsd
                    http://www.springframework.org/schema/context
                    http://www.springframework.org/schema/context/spring-context-4.2.xsd"></beans>
        使用标签
            <context:property-override location="classpath:db.properties"/>
            <context:property-override location="classpath:db.properties,classpath:log.properties"/>

Spring零配置(注解)

@Component 普通组件
@Controller 控制器组件
@Service 业务组件
@Repository 仓储(数据访问)
@Resource 配置依赖注入
@Autowired/@Qualifier 
@Scope 指定Bean的作用域
@Lazy 延迟初始化
@PostConstruct/@PreDestroy 生命周期
开启注解扫描
    <context:component-scan base-package=""></context:component-scan>
    扫面所有的 @Component/@Controller/@Service/@Repository 创建实例交给Spring容器管理

AOP

Spring+struts2

spring4.3.9+struts2.5.13
    1.拷贝Struts2的jar
        struts-2.5.13\apps\struts2-showcase\lib目录下的所有jar包
        注意:去掉spring的jar包
    2.Web应用整合Struts2
        <filter>
            <filter-name>struts-prepare</filter-name>
            <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareFilter</filter-class>
            <init-param>
                <param-name>config</param-name>
                <param-value>struts-default.xml,struts-plugin.xml,struts.xml,struts1.xml</param-value>
            </init-param>
        </filter>
         <filter-mapping>
            <filter-name>struts-prepare</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
        <filter>
            <filter-name>struts-execute</filter-name>
            <filter-class>org.apache.struts2.dispatcher.filter.StrutsExecuteFilter</filter-class>
        </filter>
         <filter-mapping>
            <filter-name>struts-execute</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
        注意:去掉一些自己不需要的配置
    3.Web应用整合Spring4(Spring容器的创建).
        默认是WEB-INF目录/WEB-INF/applicationContext*.xml 或者 applicationContext*.xml(src目录)
        <context-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/applicationContext*.xml</param-value>
        </context-param>
        <listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
        </listener>
    4.Struts2整合Spring4:
        拷贝struts-spring-plugin-xxx.jar 由struts提供,因为Spring这个框架出现的时间比Struts2晚
        作用：把action类的实例创建交给Spring创建，创建好后就会按byName为action实例中的set方法注入值.注入完成后，Spring再把action实例归还给Struts2.
    5.配置struts配置文件和spring配置文件

spring+hibernate

spring4.3.9+hibernate4.3.11
    1.拷贝hibernate的jar包
        jpa+required+optional/c3p0+mysql-connector-java-5.1.27.jar
    2.创建hibernate.cfg.xml
        <session-factory>
            <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
            <property name="hibfernate.show_sql">true</property>     
            <property name="hibernate.format_sql">true</property>   
            <property name="hibernate.hbm2ddl.auto">update</property>
            <mapping class="com.shuai.domain.User"/>
        </session-factory>
    3.创建src/db.properties
    4.拷贝Springjar包
        20个 + commons-logging-xx.jar + aop依赖的aspectjweaver.jar
    5.创建Spring的配置文件applicationContext.xml
        <beans xmlns="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:p="http://www.springframework.org/schema/p"
            xmlns:tx="http://www.springframework.org/schema/tx"
            xmlns:aop="http://www.springframework.org/schema/aop"
            xmlns:context="http://www.springframework.org/schema/context"
            xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
                http://www.springframework.org/schema/tx
                http://www.springframework.org/schema/tx/spring-tx-4.2.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context-3.0.xsd"
                default-autowire="byName"></beans>
    6.配置applicationContext.xml
        6.0注意:一定在beans加一个属性 default-autowire="byName"
        6.1加载db.properties
            <context:property-placeholder location="classpath:db.properties"/>
        6.2创建数据库连接池
            <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
                p:driverClass="${driverClass}"
                p:jdbcUrl="${jdbcUrl}"
                p:user="${user}"
                p:password="${password}"
                p:maxPoolSize="${maxPoolSize}"
                p:minPoolSize="${minPoolSize}"
                p:initialPoolSize="${initialPoolSize}"/>
        6.3创建数据库数据源
            <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"
                p:dataSource-ref="dataSource"
                p:configLocation="classpath:hibernate.cfg.xml"/>
        6.4配置aop切面
            <!-- 事务管理器-->
            <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"
                p:sessionFactory-ref="sessionFactory"/> 
            <!-- 配置事务切面bean(声明式事务配置) -->
            <tx:advice id="txAdvice" transaction-manager="transactionManager">
                <tx:attributes>
                    <tx:method name="set*" read-only="true"/>
                    <tx:method name="get*" read-only="true"/>
                    <tx:method name="*" read-only="false"/>
                </tx:attributes>
            </tx:advice>
            <!-- 事务切面(运用到哪些切入点) -->
            <aop:config>
                <aop:pointcut expression="execution(* com.shuai.service.*.*(..))" id="pointcut"/>
                <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
            </aop:config>
    7.代码
        HibernateDao.java
            public interface HibernateDao {
                <T> void save(T entity);
                <T> void update(T entity);
                <T> T get(Class<?> clazz, Serializable id);
                <T> void delete(T entity);
                <T> List<T> find(String hql);
            }
        HibernateDaoImpl.java
            public class HibernateDaoImpl extends HibernateDaoSupport implements HibernateDao {
                @Override
                public <T> void save(T entity) {
                    this.getHibernateTemplate().save(entity);
                }
                @Override
                public <T> void update(T entity) {
                    this.getHibernateTemplate().update(entity);
                }
                @Override
                public <T> T get(Class<?> clazz, Serializable id) {
                    return (T)this.getHibernateTemplate().get(clazz, id);
                }
                @Override
                public <T> void delete(T entity) {
                    this.getHibernateTemplate().delete(entity);
                }
                @Override
                public <T> List<T> find(String hql) {
                    return (List<T>)this.getHibernateTemplate().find(hql);
                }
            }
        

spring+mybatis

spring4.3.9+mybatis3.4.4
    1.拷贝mybatis3的jar包
        mybatis-3.4.4.jar+mybatis-spring-1.3.1.jar+mysql-connector-java-5.1.27.jar+c3p0-0.9.5.2.jar+mchange-commons-java-0.2.11.jar
    2.编写src/db.properties
    3.编写src/mybatis-config.xml
        <?xml version="1.0" encoding="UTF-8" ?>
        <!DOCTYPE configuration
          PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-config.dtd">
        <configuration>
            <typeAliases>
                <typeAlias type="com.shuai.domain.User" alias="User" />
            </typeAliases>
        </configuration>
    4.拷贝spring的jar包
        20个+common-logging-xx.jar
    5.配置applicationContext.xml
        5.1注意:beans中不能配置 default-autowire="byName"
        5.2加载数据库配置文件
            <context:property-placeholder location="classpath:db.properties"/>
        5.3创建数据源
            <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
                p:driverClass="${driverClass}"
                p:jdbcUrl="${jdbcUrl}"
                p:user="${user}"
                p:password="${password}"
                p:maxPoolSize="${maxPoolSize}"
                p:minPoolSize="${minPoolSize}"
                p:initialPoolSize="${initialPoolSize}"/>
        5.4创建session工厂
            <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"
                p:dataSource-ref="dataSource" p:configLocation="classpath:mybatis-config.xml" p:mapperLocations="classpath:com/shuai/domain/*.xml"/>
        5.5加载mybatis配置文件
            <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"
                p:basePackage="com.shuai.dao" p:sqlSessionFactoryBeanName="sqlSessionFactory"/>
        5.6配置事务
            <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
                p:dataSource-ref="dataSource"/>
            <tx:advice id="txAdvice">
                <tx:attributes>
                    <tx:method name="set*" read-only="true"/>
                    <tx:method name="get*" read-only="true"/>
                    <tx:method name="*" read-only="false"/>
                </tx:attributes>
            </tx:advice>
            <aop:config>
                <aop:pointcut expression="execution(* com.shuai.service.*.*(..))" id="pointcut"/>
                <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
            </aop:config>
    6.代码
        UserDao.java
            public interface UserDao {
                void insert(User user);
            }
        User.xml
            <mapper namespace="com.shuai.dao.UserDao">
                <insert id="insert" parameterType="User">
                    insert into user (name) values (#{name})
                </insert>
            </mapper>

springmvc+spring

spring+log4j