静态代理设计模式

[code]package com.learn.service;

/**
* user 服务层
* @author Leon.Sun
*
*/
public interface UserService {

/**
* 在add方法里面怎么进行处理呢
* 这里是接口不能写方法体的
*/
public void add();
}

[code]package com.learn.service.impl;

import com.learn.service.UserService;

//user 服务层
/**
* 在这里写一个实现出来
* 实现一下UserService这个接口
* @author Leon.Sun
*
*/
public class UserServiceImpl implements UserService {

/**
* spring 事务封装呢？ aop技术
* 实现完了之后讲一下方法
* Spring他是怎样进行封装的呢
* Spring的事务是怎么封装的呢
* 他其实是采用AOP技术
* 在方法之前和之后做个拦截
* 在方法之前开启事务
* 在方法运行完毕之后就提交事务
* 就是这样的
* 为了提高代码的复用性
* 我们把重复的代码抽取出来
* 放在代理类里去实现
* 你看看我之前也讲过的
* 我们是不是要写一个代码类对象
*
*/
public void add() {
System.out.println("开启事务.....");
/**
* 打印日志
* 就是往数据库添加数据....
* 在添加之前和之后要加一个事务处理
* 但是如果以后每个方法都是这样去开启事务那就非常麻烦
*/
System.out.println("往数据库添加数据...");
System.out.println("提交事务.....");
}

}

[code]package com.learn.day02;

import com.learn.service.UserService;
import com.learn.service.impl.UserServiceImpl;

public class Test001 {

public static void main(String[] args) {
/**
* 我们有一个UserServiceImpl实现
* 正常情况下我们new一个UserServiceImpl
* 这边是有一个接口UserService
*
*/
UserService userService = new UserServiceImpl();
/**
* 这个时候我们做一个调用
* 就可以实现这样的一个功能
* 开启事务
* 当我往数据库添加完了以后
* 就可以提交事务
* 这是最基本的
*/
userService.add();
//		UserServiceProxy userServiceProxy = new UserServiceProxy(userService);
//		userServiceProxy.add();
}

}

[code]package com.learn.service;

/**
* user 服务层
* @author Leon.Sun
*
*/
public interface UserService {

/**
* 在add方法里面怎么进行处理呢
* 这里是接口不能写方法体的
*/
public void add();
}

[code]package com.learn.service.impl;

import com.learn.service.UserService;

//user 服务层
/**
* 在这里写一个实现出来
* 实现一下UserService这个接口
* @author Leon.Sun
*
*/
public class UserServiceImpl implements UserService {

/**
* spring 事务封装呢？ aop技术
* 实现完了之后讲一下方法
* Spring他是怎样进行封装的呢
* Spring的事务是怎么封装的呢
* 他其实是采用AOP技术
* 在方法之前和之后做个拦截
* 在方法之前开启事务
* 在方法运行完毕之后就提交事务
* 就是这样的
* 为了提高代码的复用性
* 我们把重复的代码抽取出来
* 放在代理类里去实现
* 你看看我之前也讲过的
* 我们是不是要写一个代码类对象
*
*/
public void add() {
//		System.out.println("开启事务.....");
/**
* 打印日志
* 就是往数据库添加数据....
* 在添加之前和之后要加一个事务处理
* 但是如果以后每个方法都是这样去开启事务那就非常麻烦
*/
System.out.println("往数据库添加数据...");
//		System.out.println("提交事务.....");
}

}

[code]package com.learn.proxy;

import com.learn.service.UserService;

//静态代理设计模式
/**
* 代理类要么你去反射生成
* 要么通过字节码技术
* @author Leon.Sun
*
*/
public class UserServiceProxy {
/**
* 写完了之后的时候
*/
private UserService userService;

/**
* 通过构造函数
* 写构造函数的时候
* 传入他需要代理的接口出来
* 这个你们有没有印象
* 这个是我在很早就讲过的
* 有没有印象我们在讲字节码技术的时候
* 使用字节码技术创建类
* 有没有印象
* 我是不是讲过一个例子
* 创建一个类出来
* 像AOP底层就是把这一层
* 怎么做呢
* 我不想去创建代理对象
* 我们采用动态的
* 我们人工创建代理对象的情况下
* 他要要么通过反射机制
* 要么通过字节码技术
* 创建一个虚拟的代理类对象
* 就是这样的
* 只不过是内存里面我们线程看不到
* 这个我就不细说
* 这个原理我大体介绍一下
* 有一部分人可能之前没有学
* 我之前讲代理设计模式讲的特别深
* 把原理都扯出来了
* 代理设计模式ASM是干嘛用的
* 其实ASM就是做字节码的新增修改
* 他和动态代理有什么区别
* 静态代理是什么
* 我会演示的
* 动态代理是没有代理类这一层的
* 为什么你想想
* 如果我这个时候有几千个类需要代理
* 那你是不是需要写几千个代理类对象
* 这样代码写的太复杂了
* 我们需要一个动态的代理对象
* 我们人为看不到
* 通过虚拟技术生成出来
* 一般是字节码技术
* 或者反射技术
* 就是这样的
* 没关系我待会给你演示
* 静态代理你理不理解
* 我给你们总结一下
* 动态代理马上要讲的
*
*
*
* @param userService
*/
public UserServiceProxy(UserService userService) {
/**
* 通过构造函数把它传进来
*
*/
this.userService = userService;
}

/**
* 我在代理类里面也实现一下
*
*/
public void add() {
/**
* 这里开启事务
*/
System.out.println("静态代理 开启事务");
userService.add();
/**
* 提交事务
*/
System.out.println("静态代理  提交事务");
}

}

[code]package com.learn.day02;

import com.learn.proxy.UserServiceProxy;
import com.learn.service.UserService;
import com.learn.service.impl.UserServiceImpl;

/**
* 这个其实就叫做静态代理设计模式
* 一般AOP里面不会用静态代理设计模式
* 每个类都需要写代理类类对象
* 这样写的话性能不会很好
* 这样写的话代码也会比较多
* 不能复用
*
* @author Leon.Sun
*
*/
public class Test001 {

public static void main(String[] args) {
/**
* 我们有一个UserServiceImpl实现
* 正常情况下我们new一个UserServiceImpl
* 这边是有一个接口UserService
*
*/
UserService userService = new UserServiceImpl();
/**
* 这个时候我们做一个调用
* 就可以实现这样的一个功能
* 开启事务
* 当我往数据库添加完了以后
* 就可以提交事务
* 这是最基本的
*/
//		userService.add();
/**
* 这个时候我们用的时候就不一样了
* 要这样用了
* new一下代理类对象UserServiceProxy
* 把我们的service传进去
* 拿到了我们的代理类对象
*
*/
UserServiceProxy userServiceProxy = new UserServiceProxy(userService);
/**
* 然后通过代理类对象调用我们的方法
* 然后会打印静态代理开启事务
* 静态代理提交事务
*
*/
userServiceProxy.add();
}

}