Spring完整

Spring完整

目录

1.Spring

1.1 介绍

1.2 传统代码弊端

1.3面向接口编程

1.4.IOC

1.4.1 IOC 介绍

测试

1.4.2 spring容器说明

1.5 spring注解开发

1.5.1 配置类

1.6 单例/多例

1.6.1 说明

1.6.2 测试

1.7 懒加载机制

1.8 Spring生命周期

2.依赖注入（Dependency Injection，简称DI）

2.1 依赖注入

2.2 MVC设计思想

2.2.1 MVC设计思想说明

 2.3 “三层”代码结构

2.4 “三层”代码结构实现

2.4.1 代码结构说明

2.4.2 “三层”代码结构和MVC的关系

2.5 动态为属性赋值 *** 作

2.5.1 @Value注解说明

2.5.2 编辑properties配置文件

2.5.3 实现属性注入 *** 作

3.spring中的AOP

3.1 AOP介绍

3.2 动态代理机制-JDK

 3.2.1 动态代理的说明

3.3 动态代理机制-CGLIB

3.4 Spring AOP

3.4.1 AOP介绍

3.4.2 AOP中专业术语

3.4.3 通知类型

3.4.4 切入点表达式

3.4.5 引入AOP jar包文件

3.4.6 定义切面类

3.4.7 让AOP生效

3.4.8 编辑测试类

3.4.9 AOP形象化比喻

 3.5 关于切入点表达式解析

常用注解

---

---

1.Spring 1.1 介绍

Spring框架是一个开放源代码的J2EE应用程序框架

1.2 传统代码弊端

总结：使用一个new一个对象，耦合度高

准确：1.如果类中的属性通过new的方式直接绑定，则类与属性的耦合性高

           2.如果需要修改属性类型，则需要修改代码，后期扩展不方便

1.3面向接口编程

总结：好处：将两个对象的共同方法抽取到接口中，实现代码的解耦

           弊端：根源问题仍然没有解决，属性与类仍然绑定

准确：使用接口开发，可以在一定程度上降低类与对象的耦合性，但是属性与类绑定的事实并没              有解决

 修改后：

1.4.IOC 1.4.1 IOC 介绍

IOC全称Inversion of Control，即“控制反转”，这是一种设计思想。对象创建的权利由Spring框架完成，由容器管理对象的生命周期。

IOC理论提出的观点大体是：借助于“第三方”实现具有依赖关系的对象之间的解耦

详细内容在：http://IOC的理解

测试

（1）定义Student类

public class student {
    public void grade(){
        System.out.println("成绩合格！");
    }
}

（2）在resource的目录下创建spring.xml配置文件

（3）编辑测试类

public class test {
    public static void main(String[] args) {
        String resource="spring.xml";
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext(resource);
        student student=applicationContext.getBean(student.class);
        student.grade();
        
    }

（4）结果

成绩合格

1.4.2 spring容器说明

解释: Spring容器的数据结构是Map集合,Map,

         key是bean中id值（id的首字母都是小写）, value是通过反射机制实例化的对象.

数据结构：Map  即：Map

public class test {
    public static void main(String[] args) {
//        String resource="spring.xml";
//        ApplicationContext applicationContext=new ClassPathXmlApplicationContext(resource);
//        student student=applicationContext.getBean(student.class);
//        student.grade();
        getStudent();
    }
    public static void getStudent(){
        try {
            student student=(student) Class.forName("cn.tedu.test4.student").newInstance();
            student.grade();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

结果：与上面结果一样，即spring容器是通过反射机制创建对象

1.5 spring注解开发 1.5.1 配置类

注解1：@Configuration        标识这个一个配置类

注解2：@ComponentScan("路径")       注解包扫描，使得注解有效

注解3：@Bean       标识该方法的返回值交给spring容器管理

@Configuration
@ComponentScan("cn.tedu.test4")
public class Config {
    
    @Bean
    public student student(){
        return new student();
    }
}

1.6 单例/多例 1.6.1 说明

单例模式：Spring容器中管理对象，在内存中只有一份

多例模式：Spring容器中管理对象，在内存中有多份

1.6.2 测试

属性值：

注解4：@Scope    控制单例和多例

@Scope("singleton")     默认值 单例模式

@Scope("prototype")     多例模式

@Bean
//    @Scope("singleton")    //单例 
    @Scope("prototype")      //多例
    public student student(){
        return new student();
    }

public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext(Config.class);
        student student=context.getBean(student.class);
        student student1=context.getBean(student.class);
        System.out.println(student==student1);  //单例模式  true；多例模式  false
    }

1.7 懒加载机制

注解5：@Lazy

关于多例模式和懒加载说明：

@Lazy 只能控制单例模式，多例模式都是懒加载

1.8 Spring生命周期

阶段：对象创建   初始化   业务调用   对象销毁

注解6：@PostConstruct

注解7：@PreDestroy

@Bean

public Person person(){return new Person;}

在配置类中通过@Bean将Person交给容器管理

或者直接在Person类中加注解：@Component        交给Spring容器管理

@Component
public class Person {
    public Person() {
        System.out.println("我出生了");
    }
    @PostConstruct
    public void init(){
        System.out.println("我长大了");
    }
    public void hello(){
        System.out.println("赚钱");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("老了");
    }
}

测试类：

接口中没有提供close的方法，需要使用实现类进行 *** 作

public static void main(String[] args) {
        
        AnnotationConfigApplicationContext context=
                new AnnotationConfigApplicationContext(SpringConfing.class);
        Person person=context.getBean(Person.class);
        person.hello();
        
        context.close();
    }

结果：

2.依赖注入（Dependency Injection，简称DI） 2.1 依赖注入

DI，即Dependency Injection，依赖注入，指的是Spring在管理某个类的时候会将该类依赖的属性注入进来，也就是说在创建对象的过程中，向类里面的属性中设置值。

注解8：@Autowired      可以将容器中对象进行注入

注解9：@Component      将对象交给spring容器管理

注解10：@Qualifier        按照名称进行注入

注入：将spring容器中的对象进行引用！！！

@Autowired：可以将容器中对象进行注入

1.按照类型注入：如果注入的类型是接口，则自动查找其实现类对象进行注入

    注意：一般spring框架内部的接口都是单实现，特殊条件下可以多实现

2.按照名称注入：@Autowired + @Qualifier("dog")     一般用于多实现

@Component
public class User {
    @Autowired
    @Qualifier("cat")    //id，首字母都小写
    private Pet pet;
    public void pet(){
        pet.hello();
    }

2.2 MVC设计思想 2.2.1 MVC设计思想说明

M：Model  数据层 

V：View  视图层  

C：Control  控制层  

总结：MVC  主要目的：降低代码的耦合性，提高扩展性，方便后续开发

 2.3 “三层”代码结构

说明：基于MVC设计思想的启发，在后端为了提高代码 的扩展性，一般将后端代码分为三层

（1）Controller层：用于显示数据和接收用户输入的数据，为用户提供一种交互式 *** 作的界面。

主要作用是界面展示，接收请求，分发请求。（表现层）

注解11：@Controller        标识Controller层   

（2）Service层：主要实现后端 的业务逻辑，是系统框架中体现核心价值的部分（业务逻辑层）

注解12：@Service           标识Service层

（3）Dao层/Mapper层：主要与数据库进行交互，也把该层称之为“持久层”。是对数据库，而不是对数据的 *** 作，持久层的目的就是完成对象数据和关系数据的转换。  （数据访问层）

注解13：@Repository       标识持久层 

 三层架构的出现是为了降低耦合度，在这里，使用面向抽象编程，也就是上层对下层的调用，直接通过接口来完成，下层对上层的真正服务提供者，是下层实现的接口实现类。

Mapper实现，Service调用Mapper接口，Controller调用Service接口

2.4 “三层”代码结构实现 2.4.1 代码结构说明

1.包名：mapper   2个类：一个接口UserMapper；一个实现类UserMapperImpl

2.包名：service   2个类：一个接口UserService；一个实现类UserServiceImpl

3.包名：controller   1个类：UserController

只是说明：被调用的一般会有接口和实现类

2.4.2 “三层”代码结构和MVC的关系

毫无关系

MVC是在三层架构的基础上设计的一种框架型架构，三层架构是一种宏观的概念，而MVC就是一种比较具体的三层架构的框架实现。

二者使用范围不同：三层可以应用于任何语言、任何技术的应用程序；

                                而MVC只是为了解决B-S应用程序视图层各部分的耦合关系。

它们同时存在，也可根据情况使用其中一种。

2.5 动态为属性赋值 *** 作 2.5.1 @Value注解说明

注解14：@Value    动态为属性赋值   @Value("$(key)")

注解15：@PropertySource       加载指定路径的配置文件properties

1.编辑properties文件

注意：(1)数据结构：key=value

           (2)无需添加多余的引号

           (3)注意多余的空格   =后面的空格不算，value后面的空格算数

           (4)程序读取properties文件时，默认采用ISO-8859-1编码，中文必定乱码

2.5.2 编辑properties配置文件

2.5.3 实现属性注入 *** 作

通过@PropertySource 注解动态加载配置文件，并且指定字符集编码格式utf-8

3.spring中的AOP 3.1 AOP介绍

1.在软件业中，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程

通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

2.利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

3.AOP的主要作用：在不修改原有代码的条件下， 对方法进行扩展

3.2 动态代理机制-JDK  3.2.1 动态代理的说明

Java中提供了动态代理的机制，可以利用API在运行期动态生成一个原对象“看起来”一模一样的对象（代理对象），用户的扩展功能，在动态代理中完成。

详细内容：

一颗白杨：(46条消息) JDK动态代理_壹棵白杨的博客-CSDN博客

3.3 动态代理机制-CGLIB

特点：代理对象是目标对象的子类

3.4 Spring AOP 3.4.1 AOP介绍

1.在软件业中，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程

通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

2.利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

3.AOP的主要作用：在不修改原有代码的条件下， 对方法进行扩展

3.4.2 AOP中专业术语

1）连接点：用户可以被扩展的方法

2）切入点：用户实际扩展的方法

3）通知：扩展方法的具体实现

4）切面：将通知应用到切入点的过程

3.4.3 通知类型

1）@before通知：目标方法执行前执行

2）@afterReturning通知：目标方法执行后执行

3）@afterThrowing通知：目标方法报错时执行

4）@after通知：目标方法执行之后  最后执行

5）@around通知：目标方法执行前后都要执行

3.4.4 切入点表达式

1）bean（bean的Id号） 按照bean匹配

2）within（包名.类名） 可以通过通配符

3）execution（返回值类型  包名.类名.方法名（参数列表））

4）@annotation（包名.注解名称）

3.4.5 引入AOP jar包文件

 		
        
  	          org.springframework.boot
            spring-boot-starter-aop
        

3.4.6 定义切面类

注解16：@Aspect     表示这是一个切面类

切面=切入点表达式 + 通知方法

1.切入点：

注解17：@Pointcut     用于定义切入点表达式，表达式写法4种

  1）可以理解为就是一个if判断

  2）判断条件：切入点表达式

  3）规则：满足表达式  则判断为true，则执行通知方法

                  不满足表达式，则判断为false，则不执行通知方法

2.切入点表达式：bean/within/execution/annotation

3.4.7 让AOP生效

说明：编辑配置类，添加注解@EnableAspectJAutoProxy，让AOP机制有效

注解18：@EnableAspectJAutoProxy      让AOP的注解有效

3.4.8 编辑测试类

public class Spring_AOP {

    public static void main(String[] args) {
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //理论值:根据接口获取实现类对象, 但是与切入点表达式匹配,为了后续扩展方便.为其创建代理对象
        UserService userService = context.getBean(UserService.class);
        //如果是实现类对象,则方法没有被扩展
        //如果是代理对象, 则方法被扩展 aop有效的
        System.out.println(userService.getClass());
        userService.addUser();
    }
}

3.4.9 AOP形象化比喻

3.5 关于切入点表达式解析

3.6 Spring中的通知总结

第一类：记录程序的运行状态

1.前置通知

2.后置通知   记录目标方法的返回值

3.异常通知   记录目标方法执行之后，抛出的异常

4.最终通知   记录程序最后的状态

第二类

5.环绕通知    控制目标方法是否执行

环绕通知是未来使用最多，功能也是最强大的

常用注解

1.@Configuration 标识当前类是配置类
2.@ComponentScan 包扫描注解 扫描注解
3.@Bean 标识该方法的返回值交给Spring容器管理
4.@Scope 控制多例和单例
5.@Lazy 懒加载
6.@PostConstruct 初始化方法
7.@PreDestroy 销毁方法
8.@Component 将当前类未来的对象交给容器管理
9.@Autowired 按照类型进行注入
10.@Qualifier 按照名称进行注入
11.@Repository 标识持久层注解
12.@Service 标识Service层
13.@Controller 标识Controller层
14.@Value 为属性赋值 @Value("${key}")
15.@PropertySource 加载指定路径的配置文件properties
16.@Aspect 标识当前类是一个切面类
17.@Pointcut 用于定义切入点表达式 表达式写法4种
18.@EnableAspectJAutoProxy 让AOP的注解有效果
19.@Before AOP-前置通知
20.@AfterReturning AOP-后置通知
21.@AfterThrowing AOP-异常通知
22.@After AOP-最终通知
23.@Around AOP-环绕通知

24.@Order           实现AOP的排序

---