一.Cglib代理
1.静态代理
概述
静态代理在使用时,需要定义接口或是父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。静态代理存在一个问题:当我们在被代理的类中增加了一个方法,代理类中也要增加相应方法。
代码实现
public interface IUserDao
{
void save();
}
public class UserDao implements IUserDao
{
@Override
public void save()
{
System.out.println("已经保存数据!!!");
}
}
public class UserDaoProxy implements IUserDao
{
private IUserDao target;
public UserDaoProxy(IUserDao target)
{
this.target = target;
}
@Override
public void save()
{
System.out.println("开始事务...");
target.save();
System.out.println("提交事务...");
}
}
public class App
{
public static void main(String[] args)
{
IUserDao target = new UserDao();
IUserDao proxy = new UserDaoProxy(target);
proxy.save();
}
}
1.动态态代理
JDK代理,利用JDKAPI实现
public class ProxyFactory
{
private Object target;
public ProxyFactory(Object target)
{
this.target = target;
}
public Object getProxyInstance()
{
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
{
@Override
public Object invoke(Object proxy, Method method, Object[] args)throws Throwable
{
System.out.println("开启事务");
Object returnValue = method.invoke(target, args);
System.out.println("提交事务");
return returnValue;
}
});
}
}
public class App
{
public static void main(String[] args)
{
IUserDao target = new UserDao();
System.out.println(target.getClass());
IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
System.out.println(proxy.getClass());
proxy.save();
}
}
3.Cglib子类代理
概述
1). JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类,就可以使用CGLIB实现。
2). CGLIB是一个强大的高性能的代码生成包,它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用,例如Spring AOP和dynaop,为他们提供方法的interception(拦截)。
3). CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM,来转换字节码并生成新的类。不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。
代码实现
public class ProxyFactory implements MethodInterceptor
{
private Object target;
public ProxyFactory(Object target)
{
this.target = target;
}
public Object getProxyInstance()
{
Enhancer en = new Enhancer();
en.setSuperclass(target.getClass());
en.setCallback(this);
return en.create();
}
}
public class App
{
public static void main(String[] args)
{
UserDao target = new UserDao();
System.out.println(target.getClass());
UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
System.out.println(proxy.getClass());
proxy.save();
}
}
二.AOP编程
AOP 面向切面的编程,AOP可以实现“业务代码”与“关注点代码”分离
// 保存一个用户
public void add(User user)
{
Session session = null;
Transaction trans = null;
try
{
session = HibernateSessionFactoryUtils.getSession(); // 【关注点代码】
trans = session.beginTransaction(); // 【关注点代码】
session.save(user); // 核心业务代码
trans.commit(); //【关注点代码】
}
catch (Exception e)
{
e.printStackTrace();
if(trans != null)
{
trans.rollback(); //【关注点代码】
}
}
finally
{
//【关注点代码】
HibernateSessionFactoryUtils.closeSession(session);
}
}
分析总结:
关注点代码,就是指重复执行的代码。
业务代码与关注点代码分离的优点
关注点代码写一次即可;
开发者只需要关注核心业务;
运行时期,执行核心业务代码时候动态植入关注点代码; 【代理】
分离
过程式/对象式/代理模式分离
1.AOP概述
Aop:aspect object programming 面向切面编程
功能: 让关注点代码与业务代码分离!
关注点:重复代码就叫做关注点;
切面:关注点形成的类,就叫切面(类)!
面向切面编程:就是指 对很多功能都有的重复的代码抽取,再在运行的时候网业务方法上动态植入“切面类代码”。
切入点
执行目标对象方法,动态植入切面代码。
可以通过切入点表达式,指定拦截哪些类的哪些方法; 给指定的类在运行的时候植入切面类代码。
2.注解方式实现AOP编程
步骤:
1). 先引入aop相关jar文件(aspectj aop优秀组件)
spring-aop-3.2.5.RELEASE.jar 【spring3.2源码】
aopalliance.jar 【spring2.5源码/lib/aopalliance】
aspectjweaver.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】
aspectjrt.jar 【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】
注意: 用到spring2.5版本的jar文件,如果用jdk1.7可能会有问题。
需要升级aspectj组件,即使用aspectj-1.8.2版本中提供jar文件提供。
2). bean.xml中引入aop名称空间
3).开启aop注解
4).使用注解
@Aspect : 指定一个类为切面类
@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))") : 指定切入点表达式
@Before("pointCut_()") : 前置通知:, 目标方法之前执行
@After("pointCut_()") : 后置通知, 目标方法之后执行(始终执行)
@AfterReturning("pointCut_()") : 返回后通知, 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()") : 异常通知, 出现异常时候执行
@Around("pointCut_()") : 环绕通知, 环绕目标方法执行
源代码
public interface IUserDao
{
void save();
}
@Component // 加入容器
public class UserDao implements IUserDao
{
@Override
public void save()
{
System.out.println("核心业务:保存");
}
}
@Component
@Aspect // 指定当前类为切面类
public class Aop
{
// 指定切入点表单式: 拦截哪些方法; 即为哪些类生成代理对象
@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")
public void pointCut_()
{
}
// 前置通知 : 在执行目标方法之前执行
@Before("pointCut_()")
public void begin()
{
System.out.println("开始事务/异常");
}
// 后置/最终通知:在执行目标方法之后执行 【无论是否出现异常最终都会执行】
@After("pointCut_()")
public void after()
{
System.out.println("提交事务/关闭");
}
// 返回后通知: 在调用目标方法结束后执行 【出现异常不执行】
@AfterReturning("pointCut_()")
public void afterReturning()
{
System.out.println("afterReturning()");
}
// 异常通知: 当目标方法执行异常时候执行此关注点代码
@AfterThrowing("pointCut_()")
public void afterThrowing()
{
System.out.println("afterThrowing()");
}
// 环绕通知:环绕目标方式执行
@Around("pointCut_()")
public void around(ProceedingJoinPoint pjp) throws Throwable
{
System.out.println("环绕前....");
pjp.proceed(); // 执行目标方法
System.out.println("环绕后....");
}
}
<?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"
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>
public class App
{
ApplicationContext ac =
new ClassPathXmlApplicationContext("xml文件路径");
// 目标对象有实现接口,spring会自动选择“JDK代理”
@Test
public void testApp()
{
IUserDao userDao = (IUserDao) ac.getBean("userDao");
System.out.println(userDao.getClass());
userDao.save();
}
// 目标对象没有实现接口, spring会用“cglib代理”
@Test
public void testCglib()
{
OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
System.out.println(orderDao.getClass());
orderDao.save();
}
}
3.XML方式实现AOP编程
public interface IUserDao
{
void save();
}
public class UserDao implements IUserDao
{
@Override
public void save()
{
System.out.println("核心业务:保存");
}
}
public class OrderDao
{
public void save()
{
System.out.println("核心业务:保存");
}
}
public class Aop
{
public void begin()
{
System.out.println("开始事务/异常");
}
public void after()
{
System.out.println("提交事务/关闭");
}
public void afterReturning()
{
System.out.println("afterReturning()");
}
public void afterThrowing()
{
System.out.println("afterThrowing()");
}
public void around(ProceedingJoinPoint pjp) throws Throwable
{
System.out.println("环绕前....");
pjp.proceed();
System.out.println("环绕后....");
}
}
public class App
{
ApplicationContext ac =
new ClassPathXmlApplicationContext("xml文件路径");
@Test
public void testApp()
{
IUserDao userDao = (IUserDao) ac.getBean("userDao");
System.out.println(userDao.getClass());//$Proxy001
userDao.save();
}
// 目标对象没有实现接口, spring会用“cglib代理”
@Test
public void testCglib()
{
OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
System.out.println(orderDao.getClass());
orderDao.save();
}
}
1).dao 实例
<bean id="userDao" class="包名.UserDao"></bean>
<bean id="orderDao" class="包名.OrderDao"></bean>
2). 切面类
<bean id="aop" class="cn.itcast.f_aop_xml.Aop"></bean>
3). Aop配置
<aop:config>
<!-- 定义一个切入点表达式: 拦截哪些方法 -->
<aop:pointcut expression="execution(* cn.itcast.f_aop_xml.*.*(..))" id="pt"/>
<!-- 切面 -->
<aop:aspect ref="aop">
<!-- 环绕通知 -->
<aop:around method="around" pointcut-ref="pt"/>
<!-- 前置通知: 在目标方法调用前执行 -->
<aop:before method="begin" pointcut-ref="pt"/>
<!-- 后置通知: -->
<aop:after method="after" pointcut-ref="pt"/>
<!-- 返回后通知 -->
<aop:after-returning method="afterReturning" pointcut-ref="pt"/>
<!-- 异常通知 -->
<aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
</aop:aspect>
</aop:config>
4. 切入点表达式
1). 切面类
<bean id="aop" class="包名.Aop"></bean>
2). Aop配置
<aop:config>
<!-- 定义一个切入点表达式: 拦截哪些方法 -->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.*.*(..))" id="pt"/>-->
<!-- 【拦截所有public方法】 -->
<!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->
<!-- 【拦截所有save开头的方法 】 -->
<!--<aop:pointcut expression="execution(* save*(..))" id="pt"/>-->
<!-- 【拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->
<!--<aop:pointcut expression="execution(public * cn.itcast.g_pointcut.OrderDao.save(..))" id="pt"/>-->
<!-- 【拦截指定类的所有方法】 -->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.*(..))" id="pt"/>-->
<!-- 【拦截指定包,以及其自包下所有类的所有方法】 -->
<!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->
<!-- 【多个表达式】 -->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) || execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) or execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
<!-- 下面2个且关系的,没有意义 -->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) && execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) and execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
<!-- 【取非值】 -->
<!--<aop:pointcut expression="!execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
<aop:pointcut expression=" not execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>
<!-- 切面 -->
<aop:aspect ref="aop">
<!-- 环绕通知 -->
<aop:around method="around" pointcut-ref="pt"/>
</aop:aspect>
</aop:config>
三. Spring对jdbc支持
使用步骤:
1). 引入jar文件
spring-jdbc-3.2.5.RELEASE.jar
spring-tx-3.2.5.RELEASE.jar
2). xml文件配置
1). 数据源对象: C3P0连接池
<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="10"></property>
<property name="maxStatements" value="100"></property>
<property name="acquireIncrement" value="2"></property>
</bean>
2).创建JdbcTemplate对象
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
3). dao 实例
<bean id="userDao" class="包名.UserDao">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
java代码
public class UserDao
{
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate)
{
this.jdbcTemplate = jdbcTemplate;
}
public void save()
{
String sql = "insert into t_dept(deptName) values('test');";
jdbcTemplate.update(sql);
}
public Dept findById(int id)
{
String sql = "select * from t_dept where deptId=?";
List<Dept> list = jdbcTemplate.query(sql,new MyResult(), id);
return (list!=null && list.size()>0) ? list.get(0) : null;
}
public List<Dept> getAll()
{
String sql = "select * from t_dept";
List<Dept> list = jdbcTemplate.query(sql, new MyResult());
return list;
}
class MyResult implements RowMapper<Dept>
{
@Override
public Dept mapRow(ResultSet rs, int index) throws SQLException {
Dept dept = new Dept();
dept.setDeptId(rs.getInt("deptId"));
dept.setDeptName(rs.getString("deptName"));
return dept;
}
}
}
public class UserDao01
{
public void save()
{
try
{
String sql = "insert into t_dept(deptName) values('test');";
Connection con = null;
Statement stmt = null;
Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
stmt = con.createStatement();
stmt.execute(sql);
stmt.close();
con.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
public class UserDao02
{
private DataSource dataSource;
public void setDataSource(DataSource dataSource)
{
this.dataSource = dataSource;
}
public void save()
{
try
{
String sql = "insert into t_dept(deptName) values('test');";
Connection con = null;
Statement stmt = null;
// 连接对象
con = dataSource.getConnection();
// 执行命令对象
stmt = con.createStatement();
// 执行
stmt.execute(sql);
// 关闭
stmt.close();
con.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
public class Dept
{
private int deptId;
private String deptName;
public int getDeptId()
{
return deptId;
}
public void setDeptId(int deptId)
{
this.deptId = deptId;
}
public String getDeptName()
{
return deptName;
}
public void setDeptName(String deptName)
{
this.deptName = deptName;
}
}
public class App
{
ApplicationContext ac = new ClassPathXmlApplicationContext("包名.xml");
@Test
public void testApp() throws Exception
{
UserDao ud = (UserDao) ac.getBean("userDao");
System.out.println(ud.findById(9));
System.out.println(ud.getAll());
}
}