面向切面编程
,通过预编译方式
和运行期动态代理
实现程序功能的统一维护的一种技术。AOP是OOP(面向对象编程)的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程
的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离
,从而使得业务逻辑各部分之间的耦合度降低
,提高程序的可重用性
,同时提高了开发的效率。代理方式
向目标类织入增强代码。代理机制
进行实现。动态代理
Proxy。cglib 字节码增强
。特殊的通知
,在不修改类代码的前提下,Introduction 可以在运行期为类动态地添加一些方法或Field。1.2.1.1、目标类
UserService.java
// 目标接口
public interface UserService {
public void addUser();
public void updateUser();
public void deleteUser();
}
UserServiceImpl.java
// 目标实现类,有接口
public class UserServiceImpl implements UserService {
@Override
public void addUser() {
System.out.println("a_proxy.a_jdk addUser");
}
@Override
public void updateUser() {
System.out.println("a_proxy.a_jdk updateUser");
}
@Override
public void deleteUser() {
System.out.println("a_proxy.a_jdk deleteUser");
}
}
1.2.1.2、切面类
MyAspect.java
// 切面类
public class MyAspect {
public void before() {
System.out.println("前方法");
}
public void after() {
System.out.println("后方法");
}
}
1.2.1.3、工厂类(自定义的)
MyBeanFactory.java
// 工厂类
public class MyBeanFactory {
public static UserService createService() {
// 1、先有目标类对象
final UserService userService = new UserServiceImpl();
// 2、再有切面类
final MyAspect myAspect = new MyAspect();
/* 3、最后有代理类,将目标类(切入点)和切面类(通知)进行结合 =》 切面
* Proxy.newProxyInstance
* 参数1:ClassLoader loader 类加载器,我们知道,动态代理类在运行时创建的,任何类都需要类加载器将其加载到内存。
* 类加载器该如何写呢?
* 答:一般情况下:当前类.class.getClassLoader()
* 或者 目标类的实例.getClass().getClassLoader()
*
* 参数2:Class[] interfaces 代理类需要实现的所有接口
* 方式1:目标类的实例.getClass().getInterfaces() 注意:该方式只能获得自己接口,不能获得父元素接口
* 方式2:new Class[]{UserService.class}
* 例如:jdbc 驱动 => DriverManager => 获得接口 Connection
*
* 参数3:InvocationHandler h 处理类,是一个接口,必须进行实现类,一般情况下采用:匿名内部类
* 该接口提供了一个 invoke 方法,代理类的每一个方法执行时,都将调用一次invoke 方法
* 参数31:Object proxy 代理对象
* 参数32:Method method 代理对象当前执行的方法的描述对象(反射)
* 执行的方法名:method.getName()
* 执行的方法:method.invoke(对象, 实际参数)
* 参数33:Object[] args 方法的实际参数
*/
UserService proxyService = (UserService) Proxy.newProxyInstance(
MyAspect.class.getClassLoader(),
userService.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 前执行
myAspect.before();
// 执行目标类的方法
Object obj = method.invoke(userService, args);
// 后执行
myAspect.after();
return obj;
}
});
return proxyService;
}
}
1.2.1.4、测试类
TestJDK.java
// 测试类
public class TestJDK {
@Test
public void demo01() {
UserService userService = MyBeanFactory.createService();
userService.addUser();
userService.updateUser();
userService.deleteUser();
}
}
程度运行结果为:
前方法
a_proxy.a_jdk addUser
后方法
前方法
a_proxy.a_jdk updateUser
后方法
前方法
a_proxy.a_jdk deleteUser
后方法
1.2.2.1、目标类
UserServiceImpl.java
// 目标实现类,没接口
public class UserServiceImpl {
public void addUser() {
System.out.println("a_proxy.b_cglib addUser");
}
public void updateUser() {
System.out.println("a_proxy.b_cglib updateUser");
}
public void deleteUser() {
System.out.println("a_proxy.b_cglib deleteUser");
}
}
1.2.2.2、切面类
MyAspect.java的代码同上 1.2.1.2、切面类
代码,这里不再赘述!
1.2.2.3、工厂类(自定义的)
MyBeanFactory.java
// 工厂类
public class MyBeanFactory {
public static UserServiceImpl createService() {
// 1、先有目标类对象
final UserServiceImpl userServiceImpl = new UserServiceImpl();
// 2、再有切面类对象
final MyAspect myAspect = new MyAspect();
// 3、最后有代理类,采用cglib,底层创建目标类的子类
// 3.1、核心类
Enhancer enhancer = new Enhancer();
// 3.2 、先确定父类
enhancer.setSuperclass(userServiceImpl.getClass());
/* 3.3、 设置回调函数 ,MethodInterceptor接口 等效 jdk中的 InvocationHandler接口
* intercept() 等效 jdk中的 invoke()
* 参数1、参数2、参数3:和以invoke()方法的参数一样
* 参数4:methodProxy 方法的代理
*/
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
// 前执行
myAspect.before();
// 执行目标类的方法
Object obj = method.invoke(userServiceImpl, args);
// 执行代理类的父类,就是执行目标类(目标类和代理类是斧子关系),相当于inwoke调用了2次
methodProxy.invokeSuper(proxy, args);
// 后执行
myAspect.after();
return obj;
}});
// 4、创建代理
UserServiceImpl proxyService = (UserServiceImpl) enhancer.create();
return proxyService;
}
}
1.2.2.4、测试类
TestJDK.java的代码同上 1.2.1.4、切面类
代码,这里不再赘述!
程度运行结果为:
前方法
a_proxy.b_cglib addUser
a_proxy.b_cglib addUser
后方法
前方法
a_proxy.b_cglib updateUser
a_proxy.b_cglib updateUser
后方法
前方法
a_proxy.b_cglib deleteUser
a_proxy.b_cglib deleteUser
后方法
模拟环绕通知:
环绕通知:`必须手动执行目标方法`
try {
// 前置通知
// 执行目标方法
// 后置通知
} catch() {
// 异常抛出通知
}
UserService.java
// 目标接口
public interface UserService {
public void addUser();
public void updateUser();
public void deleteUser();
}
UserServiceImpl.java
// 目标实现类,有接口
public class UserServiceImpl implements UserService {
@Override
public void addUser() {
System.out.println("b_factory_bean addUser");
}
@Override
public void updateUser() {
System.out.println("b_factory_bean updateUser");
}
@Override
public void deleteUser() {
System.out.println("b_factory_bean deleteUser");
}
}
// 切面类
/**
* 切面类中需要删除之前自己写的通知,添加上AOP联盟提供的通知(即要增强的东西),需要实现不同接口,接口就是规范,从而就确定方法名称。
* 采用“环绕通知” MethodInterceptor
*
*/
public class MyAspect implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
System.out.println("我们的前代码");
// 使用AOP联盟的环绕通知:必须手动执行目标方法
Object obj = mi.proceed();
System.out.println("我们的后代码");
return obj;
}
}
bean.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.xsd">
<!-- 创建目标类对象 -->
<bean id="userServiceId" class="com.itheima.b_factory_bean.UserServiceImpl"></bean>
<!-- 创建切面类 -->
<bean id="myAspectId" class="com.itheima.b_factory_bean.MyAspect"></bean>
<!-- 创建代理类对象
因为我们使用的是工厂bean:FactoryBean,它的底层调用的是 getObject() 返回一个特殊的bean
工厂bean的一个具体实现类:ProxyFactoryBean类,该类用于创建代理工厂bean,生产特殊的代理对象
第一个属性:
interfaces :确定接口们
通过 <array> + <value> 可以设置多个值;
如果只有一个值时,可以简写 value=""
target :确定目标类
interceptorNames :通知,切面类的名称,类型是String[],如果设置一个值用value="" 注意:jdk1.8中不支持该属性!
optimize :强制使用cglib
<property name="optimize" value="true"></property>
创建代理类对象的底层机制:
如果目标类有接口,就采用jdk 动态代理
如果目标类没有接口,就采用cglib 字节码增强
如果声明 optimize = true ,无论是否有接口,都采用cglib 字节码增强
-->
<bean id="proxyServiceId" class="org.springframework.aop.framework.ProxyFactory">
<property name="interfaces" value="com.itheima.b_factory_bean.UserService"></property>
<property name="target" ref="userServiceId"></property>
<property name="interceptorNames" value="myAspectId"></property>
<property name="optimize" value="true"></property>
<!--
<property name="interfaces">
<array>
<value></value>
<value></value>
<value></value>
</array>
</property>
-->
</bean>
</beans>
TestFactoryBean.java
// 测试类
public class TestFactoryBean {
@Test
public void demo01() {
String xmlPath = "com/itheima/b_factory_bean/beans.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
// 获取代理类对象
UserService userService = (UserService) applicationContext.getBean("proxyServiceId");
userService.addUser();
userService.updateUser();
userService.deleteUser();
}
}
UserService.java 和 UserServiceImpl.java 代码 同 1.4.1、目标类 代码一样。
MyAspect.java 代码同 1.4.2、切面类 代码一样。
<?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: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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 1、创建目标类对象 -->
<bean id="userServiceId" class="com.itheima.c_spring_aop.UserServiceImpl"></bean>
<!-- 2、创建切面类 (通知)-->
<bean id="myAspectId" class="com.itheima.c_spring_aop.MyAspect"></bean>
<!-- 3、aop编程
3.1、 导入命名空间
3.2 、使用 <aop:config>进行配置
proxy-target-class="true" 声明使用cglib代理,否则默认使用jdk代理
<aop:pointcut> 切入点 ,从目标对象上来获得具体方法
<aop:advisor> 特殊的切面,只有一个通知 和 一个切入点
advice-ref 通知引用
pointcut-ref 切入点引用
3.3 、切入点表达式
execution(* com.itheima.c_spring_aop.*.*(..))
选择方法 返回值任意 包 类名任意 方法名任意 参数任意
-->
<aop:config proxy-target-class="true">
<aop:pointcut expression="execution(* com.itheima.c_spring_aop.*.*(..))" id="myPointCut"/>
<aop:advisor advice-ref="myAspectId" pointcut-ref="myPointCut"/>
</aop:config>
</beans>
TestFactoryBean.java
package com.itheima.c_spring_aop;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// 测试类
public class TestSpringAOP {
@Test
public void demo01() {
String xmlPath = "com/itheima/c_spring_aop/beans.xml";
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
// 获取目标类对象
UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser();
userService.updateUser();
userService.deleteUser();
}
}
程度运行结果为:
我们的前代码
c_spring_aop addUser
我们的后代码
我们的前代码
c_spring_aop updateUser
我们的后代码
我们的前代码
c_spring_aop deleteUser
我们的后代码
自定义开发
。1.execution() 用于描述方法【掌握】
语法:execution(修饰符 返回值 包.类.方法名(参数) throws异常)
修饰符,一般省略
public 公共方法
* 任意
返回值,不能省略
void 返回没有值
String 返回值字符串
* 任意
包,[可以省略]
com.itheima.crm 固定的包
com.itheima.crm.*.service crm包下面的任意子包,固定目录service(例如:com.itheima.crm.staff.service)
com.itheima.crm.. crm包下面的所有子包(含自己)
com.itheima.crm.*.service.. crm包下面的任意子包,固定目录service,service目录任意包(含自己)
类,[可以省略]
UserServiceImpl 指定的类
*Impl 以Impl结尾的类
User* 以User开头的类
* 任意的类
方法名,不能省略
addUser 固定的方法名
add* 以add开头的方法名
*Do 以Do结尾的方法名
* 任意的方法名
(参数)
() 无参
(int) 一个整型
(int, int) 两个整型
(..) 参数任意
throws,[可以省略],一般省略。
综合案例1:
execution(* com.itheima.crm.*.service..*.*(..))
综合案例2:
<aop:pointcut expression="execution(* com.itheima.*WithCommit.*(..)) ||
execution(* com.itheima.*Service.*(..))" id="myPointCut"/>
2.within:匹配包或子包中的方法(了解)
within(com.itheima.aop..*)
3.this:匹配实现了接口的代理对象中的方法(了解)
this(com.itheima.aop.user.UserDAO)
4.target:匹配实现了接口的目标对象中的方法(了解)
target(com.itheima.aop.user.UserDAO)
5.args:匹配参数格式符合标准的方法(了解)
args(int, int)
6.bean(id):对指定的bean所有的方法(了解)
bean('userServiceId')
around
:环绕通知(应用:十分强大,可以做任何事情) 模拟以上几个通知:
环绕通知:around
try {
// 前置通知:before
// 手动执行目标方法
// 后置通知:afterRetruning
} catch() {
// 抛出异常通知:afterThrowing
} finally {
// 最终通知:after
}
UserService.java 和 UserServiceImpl.java 代码 同 1.4.1、目标类 代码一样。
MyAspect.java
// 切面类,含有多个通知
public class MyAspect {
public void myBefore(JoinPoint joinPonint) {
System.out.println("我的前置通知:" + joinPonint.getSignature().getName());
}
public void myAfterReturning(JoinPoint joinPoint, Object ret) {
System.out.println("我的后置通知 : " + joinPoint.getSignature().getName() + ", --> " + ret);
}
public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("前方法");
// 手动执行目标方法
Object obj = joinPoint.proceed();
System.out.println("后方法");
return null;
}
public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
System.out.println("我的抛出异常通知 : " + e.getMessage());
}
public void myAfter(JoinPoint joinPoint) {
System.out.println("我的最终通知");
}
}
beans.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userServiceId" class="com.itheima.d_aspect.a_xml.UserServiceImpl">bean>
<bean id="myAspectId" class="com.itheima.d_aspect.a_xml.MyAspect">bean>
<aop:config>
<aop:aspect ref="myAspectId">
<aop:pointcut expression="execution(* com.itheima.d_aspect.a_xml.UserServiceImpl.*(..))" id="myPointCut"/>
<aop:after method="myAfter" pointcut-ref="myPointCut"/>
aop:aspect>
aop:config>
beans>
<bean id="userServiceId" class="com.itheima.d_aspect.b_annotation.UserServiceImpl">bean>
<bean id="myAspectId" class="com.itheima.d_aspect.b_annotation.MyAspect">bean>
<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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.itheima.d_aspect.b_annotation">context:component-scan>
<aop:aspectj-autoproxy>aop:aspectj-autoproxy>
以前:
<aop:aspect ref="myAspectId">
现在:
// 切面类,含有多个通知
@Component
@Aspect
public class MyAspect {
现在:
<aop:before method="myBefore" pointcut="execution(* com.itheima.d_aspect.b_annotation.UserServiceImpl.*(..))"/>
以前:
// 切入点在当前有效
@Before("execution(* com.itheima.d_aspect.b_annotation.UserServiceImpl.*(..))")
public void myBefore(JoinPoint joinPonint) {
System.out.println("我的前置通知:" + joinPonint.getSignature().getName());
}
以前:
<aop:pointcut expression="execution(* com.itheima.d_aspect.b_annotation.UserServiceImpl.*(..))" id="myPointCut"/>
现在:
// 声明公共切入点
@Pointcut("execution(* com.itheima.d_aspect.b_annotation.UserServiceImpl.*(..))")
private void myPointCut() {
}
以前:
<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret"/>
现在:
@AfterReturning(value="myPointCut()", returning="ret")
public void myAfterReturning(JoinPoint joinPoint, Object ret) {
System.out.println("我的后置通知 : " + joinPoint.getSignature().getName() + ", --> " + ret);
}
以前:
<aop:around method="myAround" pointcut-ref="myPointCut"/>
现在:
@Around(value="myPointCut()")
public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("前方法");
// 手动执行目标方法
Object obj = joinPoint.proceed();
System.out.println("后方法");
return null;
}
以前:
<aop:after-throwing method="myAfterThrowing" pointcut="execution(* com.itheima.d_aspect.b_annotation.UserServiceImpl.*(..))" throwing="e"/>
现在:
@AfterThrowing(value="execution(* com.itheima.d_aspect.b_annotation.UserServiceImpl.*(..))" ,throwing="e")
public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
System.out.println("我的抛出异常通知 : " + e.getMessage());
}
以前:
<aop:after method="myAfter" pointcut-ref="myPointCut"/>
现在:
@After("myPointCut()")
public void myAfter(JoinPoint joinPoint) {
System.out.println("我的最终通知");
}
MyAspect.java
package com.itheima.d_aspect.b_annotation;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
// 切面类,含有多个通知
@Component
@Aspect
public class MyAspect {
// 切入点在当前有效
// @Before("execution(* com.itheima.d_aspect.b_annotation.UserServiceImpl.*(..))")
public void myBefore(JoinPoint joinPonint) {
System.out.println("我的前置通知:" + joinPonint.getSignature().getName());
}
// 声明公共切入点
// @Pointcut("execution(* com.itheima.d_aspect.b_annotation.UserServiceImpl.*(..))")
private void myPointCut() {
}
// @AfterReturning(value="myPointCut()", returning="ret")
public void myAfterReturning(JoinPoint joinPoint, Object ret) {
System.out.println("我的后置通知 : " + joinPoint.getSignature().getName() + ", --> " + ret);
}
@Around(value="myPointCut()")
public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("前方法");
// 手动执行目标方法
Object obj = joinPoint.proceed();
System.out.println("后方法");
return null;
}
@AfterThrowing(value="execution(* com.itheima.d_aspect.b_annotation.UserServiceImpl.*(..))" ,throwing="e")
public void myAfterThrowing(JoinPoint joinPoint, Throwable e) {
System.out.println("我的抛出异常通知 : " + e.getMessage());
}
@After("myPointCut()")
public void myAfter(JoinPoint joinPoint) {
System.out.println("我的最终通知");
}
}
bean.xml
<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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.itheima.d_aspect.b_annotation">context:component-scan>
<aop:aspectj-autoproxy>aop:aspectj-autoproxy>
beans>
切面
@Aspect 用于声明切面,修饰切面类,从而获得通知。
通知
@Before 前置通知
@AfterReturning 后置通知
@Around 环绕通知
@AfterThrowing 抛出异常通知
@After 最终通知
切入点
@PointCut 该注解修饰方法格式为:private void xxx(){} 我们通过“方法名”获得切入点的引用。
CREATE DATABASE day34;
USE day34;
CREATE TABLE t_user(
id INT PRIMARY KEY AUTO_INCREMENT,
username VARCHAR(50),
PASSWORD VARCHAR(32)
);
INSERT INTO t_user(username,PASSWORD) VALUES('jack','1234');
INSERT INTO t_user(username,PASSWORD) VALUES('rose','5678');
User.java
package com.itheima.domain;
public class User {
private Integer id;
private String username;
private String password;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
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;
}
}
3.2、使用api(了解)
package com.itheima.b_api;
import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class TestAPI {
public static void main(String[] args) {
// 1、创建数据源(连接池), 使用dbcp
BasicDataSource dataSource = new BasicDataSource();
// 设置基本4项
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/day34");
dataSource.setUsername("root");
dataSource.setPassword("root");
// 2、 创建模板
JdbcTemplate jdbcTemplate = new JdbcTemplate();
jdbcTemplate.setDataSource(dataSource);
// 3、 通过api操作
jdbcTemplate.update("insert into t_user(username,password) values(?,?);", "tom", "998");
}
}
package com.itheima.b_api;
import org.apache.commons.dbcp.BasicDataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class TestAPI {
public static void main(String[] args) {
// 1、创建数据源(连接池), 使用dbcp
BasicDataSource dataSource = new BasicDataSource();
// 设置基本4项
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/day34");
dataSource.setUsername("root");
dataSource.setPassword("root");
// 2、 创建模板
JdbcTemplate jdbcTemplate = new JdbcTemplate();
jdbcTemplate.setDataSource(dataSource);
// 3、 通过api操作
jdbcTemplate.update("insert into t_user(username,password) values(?,?);", "tom", "998");
}
}
beans.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: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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 创建数据源对象,需要注入基本四项 -->
<bean id="dataSourceId" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/day34"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!-- 创建模板对象 ,需要注入数据源-->
<bean id="jdbcTemplateId" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSourceId"></property>
</bean>
<!-- 配置dao对象 -->
<bean id="userDaoId" class="com.itheima.c_dbcp.UserDao">
<property name="jdbcTemplate" ref="jdbcTemplateId"></property>
</bean>
</beans>
beans.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: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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 创建数据源对象,c3p0,需要注入基本四项 -->
<bean id="dataSourceId" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/day34"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!-- 创建模板对象 ,需要注入数据源-->
<bean id="jdbcTemplateId" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSourceId"></property>
</bean>
<!-- 配置dao对象,需要注入jdbc模板 -->
<bean id="userDaoId" class="com.itheima.d_c3p0.UserDao">
<property name="jdbcTemplate" ref="jdbcTemplateId"></property>
</bean>
</beans>
// jdbc的模板将由spring注入
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
由于每一个dao里面都需要将jdbc模板代码使用Spring注入进来(如上代码),比较麻烦,所以Spring就想了一个招:把jdbc模板代码写到一个父类中,然后让dao去继承它。这个父类叫做JdbcDaoSupport。
package com.itheima.e_JdbcDaoSupport;
import java.util.List;
import org.springframework.jdbc.core.simple.ParameterizedBeanPropertyRowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import com.itheima.a_domain.User;
public class UserDao extends JdbcDaoSupport {
// 更新用户
public void update(User user) {
String sql = "update t_user set username=?,password=? where id =?";
Object[] args = { user.getUsername(), user.getPassword(), user.getId() };
this.getJdbcTemplate().update(sql, args);
}
// 查询所有
public List<User> findAll() {
return this.getJdbcTemplate().query("select * from t_user", ParameterizedBeanPropertyRowMapper.newInstance(User.class));
}
}
beans.xml
<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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="dataSourceId" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver">property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/day34">property>
<property name="user" value="root">property>
<property name="password" value="root">property>
bean>
<bean id="userDaoId" class="com.itheima.e_JdbcDaoSupport.UserDao">
<property name="dataSource" ref="dataSourceId">property>
bean>
beans>
以后在开发中,我们会将创建数据源对象时需要注入的基本四项,放在一个properties文件中。
JdbcInfo.properties
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql://localhost:3306/day34
jdbc.user=root
jdbc.password=root
beans.xml
<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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:property-placeholder location="classpath:com/itheima/f_properties/jdbcInfo.properties"/>
<bean id="dataSourceId" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driverClass}">property>
<property name="jdbcUrl" value="${jdbc.jdbcUrl}">property>
<property name="user" value="${jdbc.user}">property>
<property name="password" value="${jdbc.password}">property>
bean>
<bean id="userDaoId" class="com.itheima.f_properties.UserDao">
<property name="dataSource" ref="dataSourceId">property>
bean>
beans>