Spring简介 笔记（一、学习思想）

目录

Spring是什么？

IOC

AOP

Spring常用的设计模式

---

Spring是什么？

轻量级：零配置编程、API使用简单

面向Bean：只需要编写非常普通的Bean

松耦合：充分利用AOP思想

万能胶：与主流框架无缝集成

设计模式：将Java中经典的设计模式运用得淋漓尽致

 

IOC

控制反转（控制权反转给Spring） 

IOC容器存的是java bean（bean：实例化出来的对象，简单讲就是将对象存入IOC容器中）

生活举例：Web容器，用来装Servlet的。  油箱，用来装油的。

代码举例：

class B extends A{

}

A a = new A();   //实例化以后用一个变量保存。（存在变量你自己可以控制）【常规方法】

@Autowite A a;    //Spring初始化，实例化（控制权）。

                             //存入IOC容器中。（存在IOC中控制权给了Spring，俗称控制反转）【Spring】

 

依赖注入

Spring的注入方式

1、setter

2、构造方法

3、强制赋值（强制赋值加了private也行）

@Autowrite InterfaceA（接口） a;  //自动把它的实现类注入进来

@Resource("aaa") A b;    //IOC容器中类的id为aaa对象自动注入到这里（可以区分父子类的）

@Autowrite A a；    //根据类型自动注入

//依赖链中的所有的对象，IOC容器里面初始化

 

AOP

Aspect Oriented Programming （面向切面编程）

AOP核心思想：解耦

先要把一个整体拆了，分别开发，等到发布的时候，再组装在一起运行

两个模块之间不能满足一定的规则，那就是说这两个模块是没有办法合并组装在一起的

 

AOP的功能完全集成到了Spring事务管理、日志和其他各种特性的上下文中。

Authentication 权限认证

Logging 日志

Transctions Manager 事务

Lazy Loading 懒加载

Context Process上下文处理

Error Handler 错误跟踪（异常捕获机制）

 

 

Spring常用的设计模式

1、代理模式：

aop可以用动态代理来实现。将子类给代理类来代理，代理类生成父类今天重写相应的方法。

特点：

1、执行者、被代理人

2、对于被代理人来说，这件事情是一定要做的，但是我们自己又不想做或者没有时间做，找代理。

3、需要获取到被代理人的个人资料。

学习举例：（Cglib）

package com.junjun.server.zuoye.proxy.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class JunJunShop implements MethodInterceptor {


    public Object getInstance(Class clazz) throws Exception{
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz); //这一步就是告诉cglib，生成的子类需要继承哪个类
        enhancer.setCallback(this); //设置回调

        //第一步、生成源代码
        //第二步、编译成class文件
        //第三步、加载到JVM中，并返回被代理对象
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("接到订单！\n");
        //这个obj的引用是由CGLib给我们new出来的
        //cglib new出来以后的对象，是被代理对象的子类（继承了我们自己写的那个类）
        //OOP, 在new子类之前，实际上默认先调用了我们super()方法的，
        //new了子类的同时，必须先new出来父类，这就相当于是间接的持有了我们父类的引用
        //子类重写了父类的所有的方法
        //我们改变子类对象的某些属性，是可以间接的操作父类的属性的
        methodProxy.invokeSuper(o,objects);
        System.out.println("\n准备菜等外买小哥过来拿！");
        System.out.println("外卖小哥拿到餐送到用户手上");

        return null;
    }
}

 

 

 

package com.junjun.server.zuoye.proxy.cglib;

public class ZhuZhu {


    public void placeAnOrder(){
        System.out.println("猪猪点了麻辣烫");
    }


}

package com.junjun.server.zuoye.proxy.cglib;

public class TestCgLib {

    public static void main(String[] args) {

        //CGLib的动态代理是通过生成一个被代理对象的子类，然后重写父类的方法
        //生成以后的对象，可以强制转换为被代理对象（也就是用自己写的类）
        //子类引用赋值给父类
        try {
            ZhuZhu zhuZhu = (ZhuZhu) new JunJunShop().getInstance(ZhuZhu.class);
            zhuZhu.placeAnOrder();

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

 

运行结果：

 

 

2、工厂模式：

1、隐藏复杂的逻辑过程，只关心结果。

简单工厂、工厂方法（重载接口）、抽象工厂（继承规则抽象类，指定默认规则）

 

3、单例模式：

常用单例模式写法

2WH（人都是有天生的惰性）

 

是什么？为什么要有单例模式？单例具体怎么实现？

举例：树叶，人都是一个单例都是第一无二的

特点：

1、保证从系统启动到系统停止，全过程只会产生一个实例。

2、当我们在应用中遇到功能性冲突的时候，需要使用单例模式。

 

单例模式的七种写法：？？？？

 

4、委派模式：

要和代理模式区分开来

特点：

1、类似中介功能（委派机制）

2、持有被委托人的引用。

3、不关心过程，只关心结果。

为什么要使用委派模式：

主要的就是隐藏具体实现逻辑

spring中的应用：IOC容器中，有一个Register的东西（为了告诉我们的容器，在这个类被初始化的过程中，需要坐很多不同的逻辑，需要实现多个任务执行者，分别实现各自的功能）

保证结果的多样性，对于用户来说是只有一种方法

 

5、策略模式：

过程不同，但结果一样。

 

6、原型模式：

1、过程相同，但结果不一样。2、数据内容完全一样，但实例不同。

应用场景：克隆，copy复杂的实体数据结构的数据。（默认浅克隆：只克隆8大基本数据类型和String）

 

7、模板模式：

1、执行流程一样，但中间的有些步骤不同。

使用举例：SpringJDBC就是用的模板模式

                  是Java规范，各个数据库厂商自己去实现

                  1、加载驱动类DriverManager

                  2、建立连接

                  3、创建语句集（标准语句集，预处理语句集）（语句集？MySQL，Oracle，SQLServer，Access）

                  4、执行语句集

                  5、结果及ResultSet 游标

现实举例：

                 泡咖啡流程：烧水、磨咖啡，冲咖啡   ---->   这个时候就可以有咖啡机出现了泡咖啡需要烧水磨咖啡这些都是固定流                     程可以交给机器自动完成，这个泡咖啡的流程就可以称为模板；

              （固定执行流程，就叫模板）

 

 

总结：