标签：构造函数 point -o 扫描 回调函数 inject address 解析 lse
1）专业术语
高内聚、低耦合：
类内部的关系越紧密越好，类与类的关系越少越好！
非侵入式设计：
侵入式设计：
引入的组件对现有的类的结构会有影响，这种就是“侵入式设计”的组件！
非侵入式设计：
引入组件对现有的类的结构没有影响！
Struts2: 侵入式设计！
Hibernate: 非侵入式设计！
Spring, 非侵入式设计
IOC 容器
Inversion of control 控制反转
控制反转容器! -à 对象创建的问题！
解释：
User user = new User(); 自己控制对象的创建
现在需要对象，自己不创建，交给外部的容器创建，叫控制反转！
IOC容器= bean.xml配置 + ApplicationContext容器类
DI
dependency injection 依赖注入
创建对象后，处理对象的依赖关系！
User user = new User();
user.setAddress(..) ;// 需要DI（依赖注入）
Aop…
2）六大模块:
Spring Core：核心功能，主要提供IOC容器，创建对象/依赖关系
Spring AOP：面向切面编程
Spring Web：对Web开发的支持
Spring DAO ：对Jdbc操作的支持
Spring ORM：对hibernate/对象关系映射的支持
Spring JEE ：对JavaEE其他模块的支持。
|
1) 引入jar文件 (3.2版本) 在这个版本中，只有spring的核心功能，spring依赖的组件，需单独下载！ 例如：日志jar文件。 |
|
commons-logging-1.1.3.jar 【单独下载】 spring-beans-3.2.5.RELEASE.jar 【spring源码, bean节点管理】 spring-context-3.2.5.RELEASE.jar 【spring上下文类】 spring-core-3.2.5.RELEASE.jar 【IOC容器】 spring-expression-3.2.5.RELEASE.jar 【spring表达式】 |
|
2) 新建applicationContext.xml , 源码中拷贝约束（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" 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.xsd"> </beans> |
|
3) 配置 |
|
<!-- 创建Dao实例 --> <bean id="userDao" class="cn.itcast.dao.UserDao"></bean> <!-- 创建Service实例 --> <bean id="userService" class="cn.itcast.service.UserService"> <property name="userDao" ref="userDao"></property> </bean> <!-- 创建Action实例 --> <bean id="userAction" class="cn.itcast.action.UserAction"> <property name="userService" ref="userService"></property> </bean> |
|
4）从IOC容器获取对象 |
|
// 容器对象(加载applicationContext.xml配置文件) ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); // 获取对象 UserAction userAction = (UserAction) ac.getBean("userAction"); userAction.execute(); |
|
<!-- 把对象加入IOC容器 --> <!-- 细节1： id 与 name： id 不能以数字开头，不能含有特殊符号, 不能有空格、逗号等； id 不能重复！ name 多个以空格或者逗号分隔。可以以数字开头，可以有特殊符合， 如果name值重复，编译没有问题但运行报错！ --> <bean id="user" name="user2,user3 user4" class="cn.itcast.a_config.User"></bean> <!-- 细节2： (单例（同一个对象）/多例) --> <!-- scope="singleton" 默认单例！ prototype表示多例 init-method="初始化方法" 在创建完对象之后执行初始化方法 destroy-method="销毁方法" 在调用容器类ac.destroy()时调用（单例有效） lazy-init="true" 延迟初始化，默认为False（单例有效）true表示第一次访问时才创建单例对象。 --> <bean id="user" class="cn.itcast.a_config.User" init-method="init" destroy-method="destroy_" lazy-init="false" scope="prototype"></bean> </beans> |
|
1）无参数构造器 <bean id="user1" class="cn.itcast.b_create_obj.User"> |
|
2）有参数构造器 <bean id="user" class="cn.itcast.b_create_obj.User"> <constructor-arg value="Jack"></constructor-arg> <--ref:表示引用的是IOC容器中的对象--> <constructor-arg ref="user1"></constructor-arg> </bean> |
|
3）工厂 <!-- * 工厂静态方法,创建对象 --> <!-- class 指定工厂的类； factory-method: 工厂类的静态方法 --> <bean id="user1" class="cn.itcast.b_create_obj.UserFactory" factory-method="getStaticInstace"></bean>
<!-- * 非静态方法创建对象 --> <!-- 先创建工厂实例 --> <bean id="factory" class="cn.itcast.b_create_obj.UserFactory"></bean> <bean id="user" factory-bean="factory" factory-method="getInstace"></bean> |
就是给对象属性赋值的几种方式：
|
1) 构造函数赋值 |
|
2) set方法注入值（最常用） <bean id="user" class="cn.itcast.c_di.User"> <property name="id" value="1000"></property> <!-- list集合赋值 --> <property name="list"> <list> <value>cn</value> <value>usa</value> </list> </property> <!-- map 集合赋值 --> <property name="map"> <map> <entry key="cn" value="China"></entry> </map> </property> <!-- Properties对象赋值 --> <property name="prop"> <props> <prop key="cn">China</prop> </props> </property> </bean> |
|
3） p名称空间，给属性注入值 xmlns:p="http://www.springframework.org/schema/p" <bean id="userDao" class="cn.itcast.d_di2.UserDao"></bean> <bean id="userService" class="cn.itcast.d_di2.UserService" p:userDao-ref="userDao"></bean> <bean id="userAction" class="cn.itcast.d_di2.UserAction" p:userService-ref="userService"></bean> |
|
4)自动装配(了解) <!-- a. default-autowire="byType" 配置到全局(配置到约束头上) 当前所有的bean都采用”根据类型自动装配“ b. 配置到bean节点 autowire="byName" 根据名称自动装配，会去容器找指定名称的对象，注入到set方法的参数中！ autowire="byType" 根据类型自动装配, 要确保该类型对应的对象在IOC容器中唯一，否则报错！ 总结：简化配置，但是维护麻烦！ --> <bean id="userService" class="cn.itcast.e_autowire.UserService" autowire="byName" ></bean> |
|
5)注解 <!-- 1. 开启注解扫描 --> <context:component-scan base-package="cn.itcast.f_anno"></context:component-scan> 代码中///把userDao对象加入IOC容器 @Component("userdao") // <bean id=userDao class="...">（类名之前） |
|
注解类型： 创建对象： @Component 表示一个组件(类)，把当前组件加入ioc容器 加入容器的组件的名称默认是类名第一个字母小写 @Component(“”) 指定加入ioc容器的组件类的类名 @Scope("prototype") 指定对象单例/多例 @Repository 标识是一个持久层的组件 @Service 标识是一个业务逻辑层的组件 @Controller 标识是一个控制层的组件 获取对象： @Resource 1. 默认根据修饰的字段名称会取ioc容器找对象自动注入 找到后注入 2. 如果名称没有找到，再根据类型查找 找到后就立刻注入 如果该类型在ioc容器中有多个对象，报错！ 3. 根据类型也没有找到对象，报错！ @Resource(name =””) 会根据指定的名称去容器找对象自动注入 |
总结：
配置方式与注解方式:
1. 配置， 便于维护
(配置过多，比较繁琐)
2. 注解， 开发方便
(简化配置，不利于后期维护，如果修改对象创建、关系处理，需要改代码！)
Proxy, 表示代理！ 提供了对目标对象另外的访问方式，即通过代理访问目标对象！
特点：
1. 目标对象必须要实现接口
2. 代理对象，要实现与目标对象一样的接口
缺点：
1. 代理对象，需要依赖目标对象的接口！
如果接口功能变化，目标对象变化，会引入代理对象的变化!
2. 对每一个目标对象，都要分别写一个代理类，麻烦！
动态代理：
1. 通常说的动态代理，就是指jdk代理!
因为是通过jdk的api在运行时期，动态的生成代理对象的！
2. 目标对象一定要实现接口, 代理对象不用实现接口!
JDK 生成代理对象的Api
|-- Proxy
|
static Object |
newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) |
参数loader : 当前目标对象使用的类加载器！
参数interfaces : 当前目标对象实现的接口
参数 h: 接口类型，事件处理器.
当执行目标对象方法的时候，会触发事件； 把当前执行的方法(method对象)，传入事件处理器方法参数中, 这样就可以根据业务逻辑，判断是否执行目标对象方法或扩展功能！
|
public class ProxyFactory { // 接收一个目标对象 private Object target; public ProxyFactory(Object target) { this.target = target; } // 返回对目标对象(target)代理后的对象(proxy) public Object getProxyInstance() { Object proxy = Proxy.newProxyInstance( target.getClass().getClassLoader(), // 目标对象使用的类加载器 target.getClass().getInterfaces(), // 目标对象实现的所有接口 new InvocationHandler() { // 执行代理对象方法时候触发 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("开启事务..."); // 执行目标对象方法 Object result = method.invoke(target, args); System.out.println("提交事务..."); return result; } } ); return proxy; } } |
u 也叫”子类代理”，在运行时动态在内存中构建子类对象的方法，从而对目标对象扩展。
u 当目标对象没有实现接口，就不能使用jdk提供的代理，可以以子类的方式实现！
u Spring也支持cglib代理，核心包中已经包含此功能！
l JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用Cglib实现。
l Cglib是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
l Cglib包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
|
//cglib代理：代理工厂，给多个目标对象生成代理对象！ public class ProxyFactory implements MethodInterceptor{ // 接收一个目标对象 private Object target; public ProxyFactory(Object target) { this.target = target; } // 返回目标对象代理后的子类对象 public Object getProxyInstance() { // 对target生成子类对象 // 字节码生成工具类 Enhancer en = new Enhancer(); // 设置父类 en.setSuperclass(target.getClass()); // 设置回调函数 en.setCallback(this); // 创建子类对象 return en.create(); } // 事件处理器，执行目标方法时候触发 @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("开启事务..."); Object result = method.invoke(target, args); System.out.println("提交事务..."); return result; } } |
在SpringAop编程中，
如果目标对象有实现接口，spring使用jdk提供的代理生成代理对象！
如果目标对象没有实现接口，使用cglib代理！
如果目标没有实现接口、且为final , 不能进行aop编程，报错！不能生成代理！
Spring生成代理对象的过程？
1. 创建容器对象的时候，根据“切入点表达式”拦截的类，生成代理对象；
2. 如果目标对象有实现接口，使用jdk代理！
3. 如果目标对象没有实现接口，使用cglib代理！
4. 从容器获取代理后的对象
5. 执行代理对象的方法，在运行时期，动态植入“切面”类中的“通知”!
概念：
Aop 编程：Aspect Object Programming 面向切面编程! (使用jdk/cglib代理)
分离业务代码与关注点代码！在执行业务代码时候动态植入关注点代码！
关注点：
重复执行的代码, 也叫关注点代码!
切面：
关注点代码形成的类，就叫做切面（例如：事务，权限控制, 日志等）
切入点表达式：
拦截方法，给方法所在的类生成代理对象！
Spring在初始化容器的时候，会根据切入点表达式的规则，会给符合拦截规则的方法所在的类生成代理对象！
1. 引入aop 相关 jar文件
(aspectj 在spring之前，面向切面开发的公用组件)
aopalliance.jar 【spring-framework-2.5.6\lib\aopalliance】
aspectjrt.jar 【spring-framework-2.5.6\lib\aspectj】
aspectjweaver.jar 【spring-framework-2.5.6\lib\aspectj】
spring-aop-3.2.5.RELEASE.jar 【Spring3.2源码】
2. 引入aop名称空间，开启aop注解
|
<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:aop="http://www.springframework.org/schema/aop" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 开启注解扫描 --> <context:component-scan base-package="cn.itcast.e_aop_anno"></context:component-scan> <!-- 开启aop注解 --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans> |
3. 使用Aop相关注解
@Aspect 指定一个类为切面类（切面类也需要实例化）
（切面类中的方法，也叫做通知）
@Before(“切入点表达式”) 前置通知【在执行目标对象方法之前执行】
@After(“切入点表达式”) 后置通知【在执行目标对象方法之后执行】
@AfterReturning() 返回通知【在执行完目标对象方法后执行，出现异常不执行】
@AfterThrowing() 异常通知【在执行目标对象方法出现异常时候执行】
@Around(“pointcut_”) 环绕通知【环绕目标方法执行】
@Pointcut 定义一个切入点表达式变量 （后面使用这个切入点表达式的时候，直接引用方法名即可）
步骤：
1. 引入aop 相关jar文件
2. bean.xml 引入aop名称空间
3. Aop配置
|
<!-- 实例dao对象 --> <bean id="userDao" class="cn.itcast.f_aop_xml.UserDao"></bean> <!-- 实例化切面对象 --> <bean id="aop" class="cn.itcast.f_aop_xml.TransactionAop"></bean> <!-- Aop相关配置 --> <aop:config> <!-- 切入点表达式定义 --> <aop:pointcut expression="execution(* cn.itcast.f_aop_xml.UserDao.*(..))" id="pt"/> <!-- 切面配置 --> <aop:aspect ref="aop"> <!-- 【前置通知】 在目标方法之前执行 --> <aop:before method="before" pointcut-ref="pt" /> <!-- 【环绕通知】 --> <aop:around method="方法名" pointcut-ref="pt"/> <!-- 【后置通知】 --> <aop:after method="方法名" pointcut-ref="pt"/> <!-- 【返回后通知】 --> <aop:after-returning method="方法名" pointcut-ref="pt"/ <!-- 异常通知 --> <aop:after-throwing method="方法名" pointcut-ref="pt"/> </aop:aspect> </aop:config> </beans> |
execution(
modifiers-pattern? 拦截的方法的访问修饰符
ret-type-pattern 方法返回类型，必须指定
declaring-type-pattern? 拦截的方法所在的类
name-pattern(param-pattern) 拦截的方法（以及方法的参数列表）
throws-pattern?) 方法声明的异常
?（表示0或1）
*（*代表任意）
参数（..表示任意）
execution(* 类名*（参数）)
|
1. 拦截指定的方法(通用) expression="execution(* cn.itcast.g_execution.UserDao.save())" 2. 拦截指定的类下所有的方法 expression="execution(* cn.itcast.g_execution.UserDao.*(..))" 3. 拦截指定包下所有的类的所有方法 expression="execution(* cn.itcast.g_execution.*.*(..))" 4. 拦截指定包，以及其子包下所有类的所有方法 expression="execution(* cn..*.*(..))" 5. 拦截所有的public方法 expression="execution(public * *(..))"
expression="execution(* save(..))"
expression="execution(* *save*(..))" 8. 拦截UserDao.save()方法与OrderDao.save() expression="execution(* cn..UserDao.save(..)) || execution(* cn..OrderDao.save(..))" expression="execution(* cn..UserDao.save(..)) or execution(* cn..OrderDao.save(..))" 9. 不拦截UserDao.save()方法 expression="!execution(* cn..UserDao.save(..))" expression=" not execution(* cn..UserDao.save(..))" 10. 拦截UserDao.save()同时拦截OrderDao.save() 注意： 这种很少用，一般都是或者的关系即: || 、 or expression="execution(* cn..UserDao.save(..)) and execution(* cn..OrderDao.save(..))" expression="execution(* cn..UserDao.save(..)) && execution(* cn..OrderDao.save(..))" |
Spring 对象Jdbc的支持，
Spring 对jdbc的操作进行了简化！
提供了JdbcTemplate模板工具类，简化jdbc的操作！
导包：
spring-jdbc-3.2.5.RELEASE.jar 工具类包
spring-tx-3.2.5.RELEASE.jar 事务支持依赖包
连接池、数据库驱动包！
|
jdbcTemplate方法： update(“sql”);增删改 query(“sql”,new MyRowMapper()，sql中的变量); |
|
// 封装Springjdbc查询的结果集 class MyRowMapper implements RowMapper<Dept>{ // 如何解析一行 @Override public Dept mapRow(ResultSet rs, int rowNum) throws SQLException { Dept dept = new Dept(); dept.setId(rs.getInt("id")); dept.setName(rs.getString("deptName")); return dept; } } |
n 事务是一组操作的执行单元，相对于数据库操作来讲，事务管理的是一组SQL指令，比如增加，修改，删除等，事务的一致性，要求，这个事务内的操作必须全部执行成功，如果在此过程种出现了差错，比如有一条SQL语句没有执行成功，那么这一组操作都将全部回滚
n 事务特性（ACID）
程序中两种事务管理方式
n 编程式事务管理
n 编写程序式的事务管理可以清楚的定义事务的边界，可以实现细粒度的事务控制，比如你可以通过程序代码来控制你的事务何时开始，何时结束等，与后面介绍的声明式事务管理相比，它可以实现细粒度的事务控制，例如jdbc,hibernate，spring中不提倡使用。
JDBC事务控制：
con.setAutoCommite (false); 设置事务手动提交
Hibernate中事务控制：
session.beginTransaction(); 开启事务
优缺点：
1. 事务控制精确
2. 事务代码，与业务逻辑处理代码，耦合在一起!
事务代码，不能共用！ 重新写事务控制操作！
开发效率低，不便于维护！ (不想用事务，要改代码！)
n 声明式事务管理 (在Spring中使用)
n 如果你并不需要细粒度的事务控制，你可以使用声明式事务，在Spring中，你只需要在Spring配置文件中做一些配置，即可将操作纳入到事务管理中，解除了和代码的耦合， 这是对应用代码影响最小的选择，从这一点再次验证了Spring关于AOP的概念。当你不需要事务管理的时候，可以直接从Spring配置文件中移除该设置
特点：
1. Spring提供的声明式事务管理，用到Aop概念！
2. 对指定的方法添加事务控制，这里只需要配置即可！
3. 修改事务控制实现或删除事务控制操作，只需要移除xml事务相关配置！
注意：
只能对某个方法应用事务！ （因为“切入点表达式”拦截的是方法，控制不了方法内部代码！）
所以，Spring声明式事务管理，即为粗粒度的事务控制！
声明式事务管理器类：
Jdbc:
DataSourceTransactionManager 管理jdbc中事务控制
Hibernate:
HibenateTransactionManager 管理hibernate中事务控制
事务控制在Service层：
步骤：
1. 引入jar文件
Spring 核心
Spring Aop 切面编程
Spring-jdbc / Spring-tx / 驱动包、连接池
2. dao/service
3. 配置
*数据源
* JdbcTemplate
* Dao/Service
* spring声明式事务管理配置
(拦截service方法的执行，动态植入事务控制代码！)
4. 使用
|
<?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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 1. 数据源配置 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> <property name="initialPoolSize" value="3"></property> <property name="maxPoolSize" value="6"></property> </bean>
<!-- 2. JdbcTemplate配置 , 注入数据源--> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"></property> </bean>
<!-- 3. dao实例，注入jdbcTemplate --> <bean id="deptDao" class="cn.itcast.a_tx_jdbc.DeptDao"> <property name="jdbcTemplate" ref="jdbcTemplate"></property> </bean>
<!-- 4. Service实例，注入dao实例 --> <bean id="deptService" class="cn.itcast.a_tx_jdbc.DeptService"> <property name="deptDao" ref="deptDao"></property> </bean>
<!-- 5. Spring声明式事务管理配置 -->
<!-- 5.1 配置事务管理器类 --> <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean>
<!-- 5.2 事务通知配置, 拦截到指定的方法后如何管理事务 --> <!--name:与事务属性关联的方法名。通配符（*）例如：find* find开头的方法--> <tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="find*" read-only="true"/> <tx:method name="get*" read-only="true"/> <tx:method name="*" read-only="false"/> </tx:attributes> </tx:advice>
<!-- 5.3 事务Aop配置 = 切入点表达式 + 应用上面的事务通知 --> <aop:config> <aop:pointcut expression="execution(* cn.itcast.a_tx_jdbc.*Service.*(..))" id="pt"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/> </aop:config>
</beans> |
步骤：
1. 引入aop相关包
2. 开启
|
<!-- 5.1 配置事务管理器类 --> <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> <!-- spring声明式事务管理，注解开启 --> <tx:annotation-driven transaction-manager="txManager"/> |
3. 使用@Transactional 注解
在需要添加事务控制的方法上写这个注解
@Transactional
写到方法上， 表示当前方法应用事务控制
写到类上， 表示当前类的所有方法都会应用事务
写到父类上， 当执行父类的这个方法时候才应用事务！
// 当前方法应用事务
@Transactional(
readOnly=false, // 读写的事务，当修改数据时候用；如果查询就设置为true
isolation=Isolation.DEFAULT, // 事务隔离级别
timeout=-1, // 事务执行的超时时间, -1 表示不超时
noRollbackFor=ArithmeticException.class, // 遇到指定的异常不回滚
propagation=Propagation.REQUIRES_NEW // 事务传播行为
)
Propagation事务传播行为:
REQUIRES_NEW 当前方法必须在事务环境下运行！且当前方法始终开启一个新的事务！
REQUIRED 当前方法必须在事务环境下运行！
如果调用当前方式时候已经有一个事务环境，当前执行方法会加入当前事务环境，就 不开启新的事务；如果调用当前方法时候没有事务环境，就开启一个新的事务!
SUPPORTS 支持事务环境！ 如果当前方法没有事务，也可以运行！
Never 当前方法不能在事务环境下运行！
Spring与Hibernate整合，
* 单例的SessionFactory对象，交给spring的IOC容器创建！
* 事务管理，交给spring声明式事务管理器
|
<?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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" 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.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 连接池, 通过spring管理 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> <property name="initialPoolSize" value="3"></property> <property name="maxPoolSize" value="6"></property> </bean>
<!-- Spring 与 Hibenate整合 (Spring创建SessionFactory) -->
<!-- 方式1： 直接加载hibernate.cfg.xml的方式，创建sessionFactory对象 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"></property> </bean> -->
<!-- 方式2： 连接池交给spring管理，其他配置还是写到hibernate.cfg.xml中 <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="dataSource" ref="dataSource"></property> <property name="configLocation" value="classpath:hibernate.cfg.xml"></property> </bean> -->
<!-- 方式3：(推荐) 所有的配置都在spring中完成--> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <!-- a. 注入连接池 --> <property name="dataSource" ref="dataSource"></property>
<!-- b. hibernate常用配置： 方言、自动建表、显示sql --> <property name="hibernateProperties"> <props> <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop> <prop key="hibernate.show_sql">true</prop> <prop key="hibernate.hbm2ddl.auto">update</prop> </props> </property>
<!-- c. 加载所有的映射(根据路径加载) <property name="mappingLocations"> <list> <value>classpath:cn/itcast/entity/*.hbm.xml</value> </list> </property> --> <!-- c. 根据目录加载所有的映射 --> <property name="mappingDirectoryLocations"> <list> <value>classpath:cn/itcast/entity</value> </list> </property> </bean>
<!-- 创建dao实例 --> <bean id="deptDao" class="cn.itcast.dao.DeptDao"> <property name="sessionFactory" ref="sessionFactory"></property> </bean>
<!-- 创建service实例 --> <bean id="deptService" class="cn.itcast.service.DeptService"> <property name="deptDao" ref="deptDao"></property> </bean>
<!-- Spring声明式事务管理配置--> <!-- a. 事务管理器 --> <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"></property> </bean>
<!-- b. 事务通知 --> <tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="*" read-only="false"/> </tx:attributes> </tx:advice>
<!-- c. Aop配置 = 切入点表达式 + 应用通知规则 --> <aop:config> <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn..*Service.*(..))"/> </aop:config> </beans> |
如下：
1. JDBC
Spring 提供了JdbcTemplate模板工具类，对原始的jdbc操作进行简化！
2. Hibernate
Spring 提供了对hibernate的sessionFactory创建的支持 (整合)
à 直接在dao中使用sessionFactory对象操作数据库
à 使用Spring提供的 HibernateTemplate 工具类操作数据库
优点： 对session的常用操作进行封装！ 比较方便!
à (推荐)HibernateDaoSupport工具类
Dao类直接继承HibernateDaoSupport工具类即可
HibernateDaoSupport对hibernateTemlate类进行了封装
标签：构造函数 point -o 扫描 回调函数 inject address 解析 lse
原文地址：https://www.cnblogs.com/fengfusheng/p/9032864.html
