#下面是资料的链接，请尊重资料的作者，不要随意转发。

1.react相关的学习资料
http://it-ebooks.flygon.net/

通知、增强处理（Advice）

通知、增强处理（Advice） 就是你想要的功能，也就是上说的安全、事物、日子等。你给先定义好，然后再想用的地方用一下。包含Aspect的一段处理代码

连接点（JoinPoint）

连接点（JoinPoint） 这个就更好解释了，就是spring允许你是通知（Advice）的地方，那可就真多了，基本每个方法的钱、后（两者都有也行），或抛出异常是时都可以是连接点，spring只支持方法连接点。其他如AspectJ还可以让你在构造器或属性注入时都行，不过那不是咱们关注的，只要记住，和方法有关的前前后后都是连接点。

切入点（Pointcut）

切入点（Pointcut） 上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有十几个连接点了对吧，但是你并不想在所有方法附件都使用通知（使用叫织入，下面再说），你只是想让其中几个，在调用这几个方法之前、之后或者抛出异常时干点什么，那么就用切入点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。

切面（Aspect）

切面（Aspect） 切面是通知和切入点的结合。现在发现了吧，没连接点什么事，链接点就是为了让你好理解切点搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的befor，after，around等就能知道），二切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。

引入（introduction）

引入（introduction） 允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗

目标（target）

目标（target）
引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咋们织入切面。二自己专注于业务本身的逻辑。

代理（proxy）

代理（proxy） 怎么实现整套AOP机制的，都是通过代理，这个一会儿给细说。

织入（weaving）

织入（weaving） 把切面应用到目标对象来创建新的代理对象的过程。

1

目标对象 – 项目原始的Java组件。

1

AOP代理  – 由AOP框架生成java对象。

1

AOP代理方法 = advice +　目标对象的方法。

example :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<!-- 通知 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 传播行为 -->
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="query*" propagation="SUPPORTS" read-only="true" />
		</tx:attributes>
	</tx:advice>
	<!-- 切面 -->
	<aop:config>
		<aop:advisor advice-ref="txAdvice"[具体的增强逻辑，此处是事物，上面已经定义好了]
			pointcut="execution(* cn.itcast.ssm.service.*.*(..))" [增强逻辑的具体作用位置]/>
	</aop:config>

1

#{}

表示一个占位符号，通过#{}可以实现 preparedStatement 向占 位符中设置值， 自动进行 java
类型和 jdbc 类型转换。#{}可以有效防止 sql 注入。 #{}可以接 收简单类型值或 pojo 属性值。 如果
parameterType 传输单个简单类型值，#{} 括号中可以是 value 或其它名称。

${}

表示拼接 sql 串，通过${}可以将 parameterType 传入的内容拼接在 sql 中 且不进行 jdbc 类型转换，
${}可以接收简单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，${}括号中只能是 value。

使用占位符的形式最终会将Java中的字符串类型数据”%王%”转换为 jdbc中的数据类型【通配符的形式】%王%，最终形成的sql语句为
SELECT * FROM user WHERE username LIKE %王%

1
2
3
4
5
6

<!-- 如果返回多个结果，mybatis 会自动把返回的结果放在 list 容器中 -->
<!-- resultType 的配置和返回一个结果的配置一样 -->
<select id="queryUserByUsername1" parameterType="string"
resultType="cn.itcast.mybatis.pojo.User">
SELECT * FROM `user` WHERE username LIKE #{username}
</select>

1
2
3

// 查询多条数据使用 selectList 方法
List<Object> list =
sqlSession.selectList("queryUserByUsername1", "%王%");

1
2
3
4
5

<!-- 如果传入的参数是简单数据类型，${}里面必须写 value -->
<select id="queryUserByUsername2" parameterType="string"
resultType="cn.itcast.mybatis.pojo.User">
SELECT * FROM `user` WHERE username LIKE '%${value}%'
</select>

1
2
3

// 查询多条数据使用 selectList 方法
List<Object> list = sqlSession.selectList("queryUserByUsername2", "
王");

使用字符串拼接的形式 不会进行数据类型的转化，最终解析出来的数据相当于带有“‘”号，此处传值的时候需要进行注意，最终形成的sql语句为
SELECT * FROM user WHERE username LIKE %王%

输入：

1
2
3
4
5
6
7

5
6 9 1 5 8
输出：
6 1 5 9 8 //前序
1 5 6 8 9 //中序
5 1 8 9 6 //后序
6 1 9 5 8 //层次

//Main函数
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
while(scanner.hasNextInt()){
int num = scanner.nextInt();
int[] array = new int[num];
for(int i = 0; i < num; i++){
array[i] = scanner.nextInt();
}
TreeNode root = new TreeNode(array[0]);
for(int i = 1; i < num; i++){
buildBST(root,array[i]);
}
DLR(root);//前序遍历
System.out.println();
LDR(root);//中序遍历
System.out.println();
LRD(root);//后序遍历
System.out.println();
levelOrder(root);//层次遍历
System.out.println();
}
}
//前序遍历非递归
public static void DLR(TreeNode node){
if(node!=null){
Stack<TreeNode> stack = new Stack<TreeNode>();
stack.push(node);
while(!stack.isEmpty()){
node = stack.pop();
System.out.print(node.val+“ “);
if(node.right!=null)stack.push(node.right);
if(node.left!=null)stack.push(node.left);
}
}
}
//中序遍历非递归
public static void LDR(TreeNode node){
Stack<TreeNode> stack = new Stack<TreeNode>();
while(node!=null || !stack.isEmpty()){
if(node!=null){
stack.push(node);
node = node.left;
}else{
node = stack.pop();
System.out.print(node.val+“ “);
node = node.right;
}
}
}
//后序遍历非递归
public static void LRD(TreeNode node){
Stack<TreeNode> stack = new Stack<TreeNode>();
TreeNode pre = node;
while(node!=null){
while(node.left!=null){
stack.push(node);
node = node.left;
}
while(node!=null && (node.right==null || node.right==pre)){
System.out.print(node.val+“ “);
pre = node;
if(stack.isEmpty()) return;
node = stack.pop();
}
stack.push(node);
node = node.right;
}
}
//层次遍历非递归
public static void levelOrder(TreeNode node){
Queue<TreeNode> queue = new LinkedBlockingQueue<TreeNode>();
queue.offer(node);
while(!queue.isEmpty()){
node = queue.poll();
System.out.print(node.val+“ “);
if(node.left!=null)queue.add(node.left);
if(node.right!=null)queue.add(node.right);
}
}
//构建二叉排序树
public static void buildBST(TreeNode node,int val){
if(node.val == val) return ;
if(val < node.val){
if(node.left==null) node.left = new TreeNode(val);
else buildBST(node.left,val);
}else{
if(node.right==null) node.right = new TreeNode(val);
else buildBST(node.right,val);
}
}


//二叉树节点结构
class TreeNode{
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val){
this.val = val;
}
}```

1

Mysql中索引的类型：

 Mysql中的索引分为三种类型：

       1.Normal:该类型的索引对建立索引的字段基本不做特殊要求【唯一性、有序性】
       2.Unique:要求建立索引的字段必须是唯一的;
       3.Full Text:当建立索引的字段是长文本类型等数据长度较长的字段时，建议使用该类型的索引;

Mysql中索引的方法:
      Mysql中的索引方法有Hash和BTree两种：

      Hash索引方法：

Hash图解

Hash 索引的缺点：

（1）Hash 索引仅仅能满足”=”,”IN”和”<=>”查询，不能使用范围查询。

由于 Hash 索引比较的是进行 Hash 运算之后的 Hash 值，所以它只能用于等值的过滤，不能用于基于范围的过滤，因为经过相应的 Hash 算法处理之后的 Hash 值的大小关系，并不能保证和Hash运算前完全一样。

（2）Hash 索引无法被用来避免数据的排序操作。

由于 Hash 索引中存放的是经过 Hash 计算之后的 Hash 值，而且Hash值的大小关系并不一定和 Hash 运算前的键值完全一样，所以数据库无法利用索引的数据来避免任何排序运算；

（3）Hash 索引不能利用部分索引键查询。

对于组合索引，Hash 索引在计算 Hash 值的时候是组合索引键合并后再一起计算 Hash 值，而不是单独计算 Hash 值，所以通过组合索引的前面一个或几个索引键进行查询的时候，Hash 索引也无法被利用。

（4）Hash 索引在任何时候都不能避免表扫描。

前面已经知道，Hash 索引是将索引键通过 Hash 运算之后，将 Hash运算结果的 Hash 值和所对应的行指针信息存放于一个 Hash 表中，由于不同索引键存在相同 Hash 值，所以即使取满足某个 Hash 键值的数据的记录条数，也无法从 Hash 索引中直接完成查询，还是要通过访问表中的实际数据进行相应的比较，并得到相应的结果。

（5）Hash 索引遇到大量Hash值相等的情况后性能并不一定就会比B-Tree索引高。

对于选择性比较低的索引键，如果创建 Hash 索引，那么将会存在大量记录指针信息存于同一个 Hash 值相关联。这样要定位某一条记录时就会非常麻烦，会浪费多次表数据的访问，而造成整体性能低下。
2.BTree:
二叉查找树

二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树：

1. 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

2. 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

3. 任意节点的左、右子树也分别为二叉查找树。

4. 没有键值相等的节点。

总结：两种索引方法的最终目的都是通过减少查询次数增加了查询的效率，最终达到了数据库优化的效果，但两者都在一定程度上增加了数据库的系统开销，或是内存上的，或是执行效率撒谎那个的。

12.Servlet的生命周期
1)加载：在下列时刻加载 Servlet：
（1）如果已配置自动加载选项，则在启动服务器时自动加载 (web.xml中 设置)；
（2）在服务器启动后，客户机首次向 Servlet 发出请求时;
（3）重新加载 Servlet 时（只执行一次）

2)实例化：加载 Servlet 后，服务器创建一个 Servlet 实例。（只执行一次）

3)初始化：调用 Servlet 的 init() 方法。在初始化阶段，Servlet 初始化参数被传递给 Servlet 配置对象ServletConfig。 （只执行一次）[因此Servlet是单例的，线程不安全的]

4)请求处理：对于到达服务器的客户机请求，服务器创建针对此次请求的一个“请求”对象和一个“响应”对象。服务器调用 Servlet 的 service() 方法，该方法用于传递“请求”和“响应”对象。service() 方法从“请求”对象获得请求信息、处理该请求并用“响应”对象的方法以将响应传回客户机。service() 方法可以调用其它方法来处理请求，例如 doGet()、doPost() 或其它的方法。（每次请求都执行该步骤）

5)销毁：当服务器不再需要 Servlet, 或重新装入 Servlet 的新实例时，服务器会调用 Servlet 的 destroy() 方法。（只执行一次）

B/S结构，即Browser/Server(浏览器/服务器)结构，是随着Internet技术的兴起，对C/S结构的一种变化或者改进的结构。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现，节约了开发成本，便于软件维护。
区别

1、C/S是建立在局域网的基础上的。B/S是建立在广域网的基础上的，但并不是说B/S结构不能在局域网上使用。
2、B/S业务扩展简单方便，通过增加页面即可增加服务器功能。C/S的客户端还需要安装专用的客户端软件，不利于扩展。
3、B/S维护简单方便。开发、维护等几乎所有工作也都集中在服务器端，当企业对网络应用进行升级时，只需更新服务器端的软件就可以，这减轻了异地用户系统维护与升级的成本。
4、B/S响应速度不及C/S；
5、B/S用户体验效果不是很理想

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
代理模式使用的场景非常多，例如框架中的AOP思想的实现。
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法，即狭义上的开闭原则

举个例子来说明代理的作用:假设我们想邀请一位明星,那么并不是直接连接明星,而是联系明星的经纪人,来达到同样的目的.明星就是一个目标对象,他只要负责活动中的节目,而其他琐碎的事情就交给他的代理人(经纪人)来解决.这就是代理思想在现实中的一个例子

用图表示如下:

代理模式的关键点是:代理对象与目标对象.代理对象是对目标对象的扩展,并会调用目标对象

1.1.静态代理

静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.

下面举个案例来解释:
模拟保存动作,定义一个保存动作的接口:IUserDao.java,然后目标对象实现这个接口的方法UserDao.java,此时如果使用静态代理方式,就需要在代理对象(UserDaoProxy.java)中也实现IUserDao接口.调用的时候通过调用代理对象的方法来调用目标对象.
需要注意的是,代理对象与目标对象要实现相同的接口,然后通过调用相同的方法来调用目标对象的方法

代码示例:
接口:IUserDao.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * 接口
 */
public interface IUserDao {
    void save();
}
目标对象:UserDao.java
/**
 * 接口实现
 * 目标对象
 */
public class UserDao implements IUserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}

代理对象:UserDaoProxy.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/**
 * 代理对象,静态代理
 */
public class UserDaoProxy implements IUserDao{
    //接收保存目标对象
    private IUserDao target;
    public UserDaoProxy(IUserDao target){
        this.target=target;
    }
    public void save() {
        System.out.println("开始事务...");
        target.save();//执行目标对象的方法
        System.out.println("提交事务...");
    }
}

测试类:App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        //目标对象
        UserDao target = new UserDao();
        //代理对象,把目标对象传给代理对象,建立代理关系
        UserDaoProxy proxy = new UserDaoProxy(target);
        proxy.save();//执行的是代理的方法
    }
}

静态代理总结:

1
2
3
4
5
6

1.可以做到在不修改目标对象的功能前提下,对目标功能扩展.
2.缺点:
    因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护.
如何解决静态代理中的缺点呢?答案是可以使用动态代理方式

1.2.动态代理

动态代理有以下特点:

1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理

JDK中生成代理对象的API
代理类所在包:java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

注意该方法是在Proxy类中是静态方法,且接收的三个参数依次为:

ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的
Class<?>[] interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型
InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入

代码示例:
接口类IUserDao.java以及接口实现类,目标对象UserDao是一样的,没有做修改.在这个基础上,增加一个代理工厂类(ProxyFactory.java),将代理类写在这个地方,然后在测试类(需要使用到代理的代码)中先建立目标对象和代理对象的联系,然后代用代理对象的中同名方法

代理工厂类:ProxyFactory.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
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(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始事务2");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事务2");
                        return returnValue;
                    }
                }
        );
    }
}

测试类:App.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        // 目标对象
        IUserDao target = new UserDao();
        // 【原始的类型 class cn.itcast.b_dynamic.UserDao】
        System.out.println(target.getClass());
        // 给目标对象，创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxy.getClass());
        // 执行方法   【代理对象】
        proxy.save();
    }
}

总结:
代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理
1.3.Cglib代理

上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.
Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.

Cglib子类代理实现方法:
1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在内存中动态构建子类
3.代理的类不能为final,否则报错
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

代码示例:
目标对象类:UserDao.j/**

• 目标对象,没有实现任何接口
  */
  public class UserDao {

  public void save() {

  System.out.println("----已经保存数据!----");
  

  }
  }ib代理工厂:ProxyFactory.j/**

• Cglib子类代理工厂

• 对UserDao在内存中动态构建一个子类对象
  */
  public class ProxyFactory implements MethodInterceptor{
  //维护目标对象
  private Object target;

  public ProxyFactory(Object target) {

  this.target = target;
  

  }

  //给目标对象创建一个代理对象
  public Object getProxyInstance(){

  //1.工具类
  Enhancer en = new Enhancer();
  //2.设置父类
  en.setSuperclass(target.getClass());
  //3.设置回调函数
  en.setCallback(this);
  //4.创建子类(代理对象)
  return en.create();
  

  }

  @Override
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {

  System.out.println("开始事务...");
  
  //执行目标对象的方法
  Object returnValue = method.invoke(target, args);
  
  System.out.println("提交事务...");
  
  return returnValue;
  

  }
  }:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * 测试类
 */
public class App {
    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();
        //代理对象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();
        //执行代理对象的方法
        proxy.save();
    }
}

在Spring的AOP编程中:
如果加入容器的目标对象有实现接口,用JDK代理
如果目标对象没有实现接口,用Cglib代理

适配器模式(Adapter Pattern)：将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。适配器模式是一种常用设计模式，适配器模式是对类的增强，例如[在Spring AOP中使用适配器模式将通知封装为对应的方法拦截器。](http://blog.csdn.net/adoocoke/article/details/8286902)

适配器模式有类适配器模式和对象的适配器模式两种不同的形式。如下图所示，左边是的类的适配器模式（继承），右边是对象的适配器模式（引用）。

两种适配器模式中，对象适配器更为灵活，对象适配器可以根据给定的源（adaptee）灵活的适配多个对象，而类适配器适配的对象则是固定的，不利于扩。针对不同的使用场景，两者各有优点。

类的适配器模式

类的适配器模式把被适配的类的API转换成目标类的API，其静态结构图如下所示。

在上图中可以看出，Adaptee类并没有simpleOperation2()方法，而客户端则期待这个方法。为使客户端能够使用Adaptee类，提供一个中间环节，即类Adapter，把Adaptee的API与Target类的API衔接起来。Adapter与Adaptee是继承关系，这决定了这个适配器模式是类的。

模式所涉及的角色有：

目标（Target）角色：这就是所期待得到的接口。注意，由于这里讨论的是类适配器模式，因此目标不可以是类。
源（Adaptee）角色：现有需要配置的接口。
适配器（Adapter）角色：适配器类是本模式的核心。适配器把源接口转换成目标接口。显然，这一叫色不可以是接口，而必须是具体类。

对象的适配器模式

与类的适配器模式一样，对象的适配器模式把被适配的类的API转换成目标类的API，与类的适配器模式不同的是，对象的适配器模式不是使用继承关系连接到Adaptee类，而是使用委派关系连接到Adaptee类。对象的适配器模式的静态结构如下图所示。

从上图中可以看出，Adaptee类并没有simpleOperation2()方法，而客户端则期待这个方法。为使客户端能够使用Adaptee类，需要提供一个包装（Wrapper）类Adapter。这个包装类包装了一个Adaptee的实例，从而此包装类能够把Adaptee的API与Target类的API衔接起来。Adapter与Adaptee是委派关系，这决定了这个适配器模式是对象的。
从上图可以看出，模式所涉及的角色有：

目标（Target）角色：这就是所期待的接口，目标可以是具体的或抽象的类。
源（Adaptee）角色：现有需要适配的接口。
适配器（Adapter）角色：适配器类是本模式的核心。适配器把源接口转换成目标接口，显然，这一角色必须是具体类。

***代码示例***

类的适配器模式代码

1
2
3
4
5
6
7
8
9
10
11
12

public interface Target {
    /**
     * 这是源类也有的方法simpleOperation1
     */
    void simpleOperation1();
    /**
     * 这是源类没有的方法simpleOperation2
     */
    void simpleOperation2();
}

上面给出的是目标角色的源代码，这个角色是以一个Java接口的形式实现的。可以看出，这个接口声明了两个方法：simpleOperation1()和simpleOperation2()。而源角色Adatpee是一个具体类，它有一个simpleOperation1()方法，但是没有simpleOperation2()方法，如下面代码清单所示。

1
2
3
4
5
6

public class Adaptee {
    /**
     * 源类含有方法simpleOperation1
     */
    public void simpleOperation1(){};
}

适配器角色Adapter扩展了Adaptee,同时又实现了目标接口。由于Adaptee没有提供simpleOperation2()方法，而目标接口又要求这个方法，因此适配器角色Adatper实现了这个方法，如下面代码清单所示。

1
2
3
4
5
6
7
8
9
10
11

public class Adapter extends Adaptee implements Target {
    /**
     * 由于源类没有方法simpleOperation2
     * 因此适配器类补充上这个方法
     */
    @Override
    public void simpleOperation2() {
    }
}

类的适配器模式的效果：

缺点: 使用一个具体类把源（Adaptee）适配到目标（Target）中。这样一来，如果源以及源的子
类都使用此类适配，就行不通了。
由于适配器类是源的子类，因此可以适配器类中之换掉（Override）源的一些方法。
由于只引进了一个适配器类，因此只有一个路线到目标类，使问题得到简化。

对象的适配器模式代码

1
2
3
4
5
6
7
8
9
10
11

public interface Target {
    /**
     * 这是源类也有的方法simpleOperation1
     */
    void simpleOperation1();
    /**
     * 这是源类没有的方法simpleOperation2
     */
    void simpleOperation2();
}

上面给出的是目标角色的源代码，这个角色是以一个Java接口的形式实现的。可以看出，这个接口声明了两个方法：simpleOperation1()和simpleOperation2()。而源角色Adapatee是一个具体类，它有一个simpleOperation1()方法，但是没有simpleOperation2()方法，如下面带入清单所示。

1
2
3
4
5
6

public class Adaptee {
    /**
     * 源类含有方法simpleOperation1
     */
    public void simpleOperation1(){};
}

适配器类的源代码如下面代码清单所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        super();
        this.adaptee = adaptee;
    }
    /**
     * 源类有方法simpleOperation1
     * 因此适配器类直接委派即可
     */
    @Override
    public void simpleOperation1() {
        adaptee.simpleOperation1();
    }
    /**
     * 源类没有方法simpleOperation2
     * 因此适配器类补充上这个方法
     */
    @Override
    public void simpleOperation2() {
        //write you code here
    }
}

对象的适配器模式的效果：

1

**一个适配器可以把多种不同的源适配到同一个目标。换言之，同一个适配器可以把源类和它的子类都适配到目标接口。**

与类的适配器模式相比，要想置换源类的方法就不容易。如果一定要置换掉源类的一个或多个方法，就只好先做一个源类的子类，将源类的方法置换掉，然后再把源类的子类当作真正的源进行适配。
虽然想要置换源类的方法不容易，但是要想增加一些新的方法则方便得很，而且新增加的方法可同时适用于所有的源。

总结

适配器模式将现有接口转化为客户类所期望的接口，实现了对现有类的复用，它是一种使用频率非常高的设计模式，在软件开发中得以广泛应用，在Spring等开源框架、驱动程序设计（如JDBC中的数据库驱动程序）中也使用了适配器模式。

1. 主要优点
   无论是对象适配器模式还是类适配器模式都具有如下优点：

   将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，无须修改原有结构。
   增加了类的透明性和复用性，将具体的业务实现过程封装在适配者类中，对于客户端类而言是透明的，而且提高了适配者的复用性，同一个适配者类可以在多个不同的系统中复用。
   灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。

具体来说，类适配器模式还有如下优点：

由于适配器类是适配者类的子类，因此可以在适配器类中置换一些适配者的方法，使得适配器的灵活性更强。

对象适配器模式还有如下优点：

一个对象适配器可以把多个不同的适配者适配到同一个目标；
可以适配一个适配者的子类，由于适配器和适配者之间是关联关系，根据“里氏代换原则”，适配者的子类也可通过该适配器进行适配。

1. 主要缺点
   类适配器模式的缺点如下：

   对于Java、C#等不支持多重类继承的语言，一次最多只能适配一个适配者类，不能同时适配多个适配者；
   适配者类不能为最终类，如在Java中不能为final类，C#中不能为sealed类；
   在Java、C#等语言中，类适配器模式中的目标抽象类只能为接口，不能为类，其使用有一定的局限性。

对象适配器模式的缺点如下：

与类适配器模式相比，要在适配器中置换适配者类的某些方法比较麻烦。如果一定要置换掉适配者类的一个或多个方法，可以先做一个适配者类的子类，将适配者类的方法置换掉，然后再把适配者类的子类当做真正的适配者进行适配，实现过程较为复杂。

1. 适用场景
   在以下情况下可以考虑使用适配器模式：

   系统需要使用一些现有的类，而这些类的接口（如方法名）不符合系统的需要，甚至没有这些类的源代码。
   想创建一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作。
   （对对象的适配器模式而言）在设计里，需要改变多个已有的子类的接口，如果使用类的适配器模式，就要针对每一个子类做一个适配器类，而这不太实际。

整理的适配器模式思维导图

JAVA:
crossoverjie的博客
Jark‘s的博客