0217-代理模式、切面编程、IoC和DI、日期处理常用类

• 代理设计模式（Proxy）

什么叫代理设计模式？

代理设计模式就是为当前对象，找一个代理对象，帮当前对象扩展一些其他的功能。

代理对象 就是 当前对象 功能的扩展。

---

代理模式的分类：

现在的代理设计模式有 静态代理 和动态代理 两类。

静态代理：

------编写一个代理类，实现对被代理类的功能的扩展。

动态代理：

------代理类是在程序运行过程中，动态生成的类，实现对被代理类的功能的扩展。

---

使用继承实现功能的扩展：

//此处A为目标类，也称为被代理类（父类）
public class A{
	public void fun(){
		System.out.println("A.fun()!!!")
	}
}

代理类：

//代理类，（子类）
public class ProxyA extends A{
	@Override
	public void fun(){
		super.fun();  //此处调用父类的fun方法
		proxyFun();  //此处为扩展的方法
	}
	public void proxyFun(){
		System.out.println("ProxyA.proxyFun()!!!")
	}
}

测试类：

public static void main(String[] args){
	A a = new ProxyA();
	a.fun();
}

---

• 静态代理设计模式

编写代理接口：

编写代理接口是用来暴露需要被代理的方法。（代理对象和被代理对象实现同一个接口）

public interface Proxy{
	void fun();
}

编写被代理类：

public class Service implements Proxy{
	@Override
	public void fun(){
		System.out.println("被代理的fun（）")
	}
}

编写代理类：

静态代理模式是针对接口实现的代理。

1. 与被代理类实现同一个代理接口（知道哪个方法需要被代理）
2. 在代理类中编写代理接口的属性作为 被代理对象。

public class ProxyImpl implements Proxy{
	private Proxy proxyTarget;  //此中传入被代理对象
	public ProxyImpl (Proxy proxyTarget){
		this.proxyTarget = proxyTarget;
	}
	@Override
	public void fun(){
		System.out.println("功能之前的功能扩展");
		proxyTarget.fun();
		System.out.println("功能之后的功能扩展")
	}
}

编写测试类：

public static void main(String[] args){
	Service service = new Service();  //被代理对象
	ProxyImpl proxyImpl = new ProxyImpl(service );  //代理对象
	proxyImpl.fun();
}

• 找切面（面向切面编程 AOP）

切面：

面向切面编程中，切面就是可以加入到原功能位置中的代码。

代理结构下哪些地方可以加入切面？

以我们已经学过的 try-catch 异常处理：
每一行代码最完整的结构如下：

try{
}catch(Exception e){
}finally{
}

有一行代码加入到这个结构中时：

try{
	//代码；
}catch(Exception e){
}finally{
}

能加代码的位置就是固定的四个。

try{
	前（）；
	//代码；
	后（）；
}catch(Exception e){
	异常（）；
}finally{
	最终（）；
}

从上述代码中可以看到只有4个地方可以加入切面代码。

编写切面接口：

在这个接口中，我们可以编写四个方法，分别对应其中的四个位置。

public interface AOP{
	void before();
	void after();
	void exception();
	void finall();
}

编写AOP的实现类：

public class AopImpl implements AopInterFace {
    @Override
    public void before() {
        System.out.println("开始事务！");
    }

    @Override
    public void after() {
        System.out.println("提交事务！");
    }

    @Override
    public void exceptions() {
        System.out.println("回滚事务！");
    }

    @Override
    public void finall() {
        System.out.println("关闭事务！");
    }
}

修改代理类：

public class ProxyImpl implements Proxy {
    private Proxy proxy;
    private AopInterFace aop;

    public ProxyImpl(Proxy proxy, AopInterFace aop) {
        this.proxy = proxy;
        this.aop = aop;
    }

    @Override
    public void fun() {
        try {
            aop.before();
            //fun中使用throws抛出异常，谁调用它谁来处理（此处通过try来进行捕获）
            proxy.fun();
            aop.after();
        }catch (Exception e){
            aop.exceptions();
            e.printStackTrace();
        }finally {
            aop.finall();
        }
    }
}

编写测试类：

被 代理对象 和 代理内容（切面编程内容）都交给代理对象。

public static void main(String[] args){
	Service service = new Service();
	AopImpl aopImpl = new AopImpl();
	ProxyImpl proxyImpl = new ProxyImpl(service,aopImpl);
	proxyImpl.fun();
}

---

• IoC 和 DI

中文说明：

IoC：控制反转。

-----------说的是，service 获取 dao 对象的方式。
（我们讨论的是 service 如何获得一个 dao 对象）

第一版： 主动获取

在 Service 类中使用 new 关键字，创建了一个依赖的 DAO 对象。
Service 类使用哪一个 DAO ，是在Service 类中自己说了算的。

public class DaoOne {
}

public class ServiceOne {
    private DaoOne daoOne = new DaoOne();
}

出现的问题：耦合度太高。

第二版： 被动接收

降低耦合度：

1. 删除 new
2. 创建接口

public interface Dao {
}

public class DaoTwo implements Dao {
}

Service 类中：

public class ServiceTwo {
    private Dao dao;

    public void setDao(Dao dao) {
        this.dao = dao;
    }
}

在测试类中：

public static void main(String[] args) {
    DaoTwo daoTwo = new DaoTwo();
    ServiceTwo serviceTwo = new ServiceTwo();
    serviceTwo.setDao(daoTwo);  //依赖的 注入
}

IoC：控制反转。从原来的 主动接收 变成 现在的 被动接收。控制权发生了改变。

DI：依赖注入。外部通过指定的方法为 Service 类注入依赖关系对象。

---

• 日期处理常用类

在 Java 中日期处理类型的类有两个：java.util.Date 和 java.util.Calander 类。
还有一个比较常用的日期格式化的类：SampleDateFormat 类。

Date 类：

表示日期的类。有点旧，有点老。
使用 Date 可以最快的获取当前的系统时间。

构造方法：

1. public Date(){} 获取系统当前的时间。
2. public Date(long date) 按1970.1.1 到指定时间的毫秒值来获取系统时间。

public static void main(String[] args) {
//        获取系统当前日期时间
    Date date = new Date();
    System.out.println(date);
}
出处为：Fri Feb 17 19:18:05 CST 2023  //格林尼治标准时间

常用方法：

public long getTime() 返回对象表示日期到1970.1.1的毫秒值。
--------使用毫秒值与其他日期类型进行转换。

java.sql.Date 类：

java.sql.Date 类是一个用来表示 数据库 中 日期类型的对象。

public static void main(String[] args) {
//        获取系统当前日期时间
    Date date = new Date();
    System.out.println(date);
    System.out.println(date.getTime());

//数据库中的Date
	java.sql.Date d = new java.sql.Date(date.getTime)

SimpleDateFormat 类：

SimpleDateFormat 类是对 Date 数据类型进行格式化的类。

构造方法：

SimpleDateFormat(String pattern) 使用给定模式 SimpleDateFormat 并使用默认的 FORMAT 语言环境的默认日期格式符号。

String pattern 这是一个模式字符串，使用一些标准的字母表示特定的日期字段。例如下图所示：

使用格式例如：

Date date = new Date();
System.out.println(date);

System.out.println(date.getTime());

//        日期格式化
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日，HH点mm分");
String format = simpleDateFormat.format(date);
System.out.println(format);