Spring

1. Spring框架简介

Spring框架:一个开放源代码的J2EE应用程序框架，是针***对bean的生命周期进行管理***的轻量级***容器***（lightweight container).Spring框架主要由七部分组成，分别是 Spring Core、 Spring AOP、 Spring ORM、 Spring DAO、Spring Context、 Spring Web和 Spring Web MVC。
J2EE: JAVA企业级开发
bean: 由Spring容器管理的对象
容器: Spring在内存中开辟的用来管理对象的空间.
一句话总结:Spring是开源的J2EE应用框架,是管理Bean生命周期的轻量级容器!

2. Spring框架引入的方便性

2.1 传统项目开发的弊端

2.1.1 创建一个父类接口Pet和俩个类Dog/Cat

package com.tgb.demo1;
//面向接口编程 创建接口抽取共性
public interface Pet {
//定义俩个共性方法
     void call();
     void eat();
}

package com.tgb.demo1;
//创建子类实现并重写父类功能
public class Dog implement Pet {
    @Override
    public void call(){
        System.out.println("小狗 汪汪叫");
    }
    @Override
    public void eat(){
        System.out.println("小狗 吃骨头");
    }
}

package com.tgb.demo1;
//创建子类实现并重写父类功能
public class Cat implement Pet {
    @Override
    public void call(){
        System.out.println("小猫 喵喵叫");
    }
    @Override
    public void eat(){
        System.out.println("小猫 爱吃鱼");
    }
}

2.1.2 创建测试类Master

package com.tgb.demo1;
public class Master {
    //主人想调用eat和call方法 首先要创建对象
    private  Cat cat = new Cat();//对象绑定
    private  Dog dog = new Dog();//对象绑定
    // 多态思想 父类形参 子类实参
    public  void feed(Pet pet) {//pet参数需要手动切成 cat/dog
        pet.call();
        pet.eat();
    }
    /**
     * 分析这段代码有什么缺点:
     *  1.如果用户需要切换宠物.则手动的修改参数
     *  2.每个宠物对象都与当前的类Master紧紧的绑定在一起.后期维护不易!!
     *  总结: 这样的程序设计耦合性高,不利于开发
     */
}

2.1.3 测试问题总结

1.如果用户想调用某类的功能必须通过new 的方式创建对象并与用户直接绑定. 则用户与类功能的耦合性高.
2.如果需要修改对象类型, 则需要修改代码. 后期扩展不方便.

2.2 Spring核心-IOC的引入

2.2.1 IOC介绍

Ioc全称Inversion of Control，即“控制反转”，这是一种设计思想。对象创建的权利由Spring框架完成.由容器管理对象的生命.
作用:由容器管理对象的生命,解决了传统项目开发的弊端.

2.2.2 IOC入门案例

2.2.2.1 准备Dog类

package com.tgb.demo2;
//创建子类实现并重写父类功能
public class Dog implement Pet {
    @Override
    public void call(){
        System.out.println("小狗 汪汪叫");
    }
    @Override
    public void eat(){
        System.out.println("小狗 吃骨头");
    }
}

2.2.2.2准备spring.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--1. IOC的机制管理Dog对象
        id: 对象的唯一标识符. 不能重复 见名知意 首字母小写
        class: 类路径
    -->
    <bean id="dog" class="com.jt.demo2.Dog"></bean>
</beans>

2.2.2.3 编辑User测试对象

package com.jt.demo2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class User {
    //IOC!!!!
    public static void main(String[] args) {
        //1.指定配置文件
        String resource = "spring.xml";
        //2.创建容器对象  加载配置文件
        ApplicationContext context =
                new ClassPathXmlApplicationContext(resource);
        //3.从容器中获取对象
        Dog dog = context.getBean(Dog.class);
        //4.调用对象的方法
        dog.call();
        dog.eat();
    }
}

2.2.2.4 IOC对象创建-反射机制

package com.jt.demo2;
public class TestDog {
    /**
     *  1.该方法是通过反射的机制实例化对象 !!!框架中的重点!!!
     *  2.反射机制:
     *      java中创建对象的常用的一种方式,指定类型的路径,
     *      之后通过关键方法.newInstance()实例化对象
     *      类比:  xxx.newInstance() ~~ new Dog();
     *  3. 精髓: 为什么用反射/而不是new?
     *      3.1 因为第三方通过反射实例化对象 可以实现松耦合!!
     *      3.2 一般多用于框架,因为框架不清楚用户到底需要啥,只有运行期
     *          才清楚用户到底需要什么对象. 扩展性更好!!!
     *  4. 异常说明:
     *         1.运行时异常   运行期间出错了
     *         2.编译异常/检查异常  编译时提示报错
     */
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Dog dog = (Dog) Class.forName("com.jt.demo2.Dog")//默认字节码对象是超类object需要 向下造型
                .newInstance();//利用无参构造创建对象
        dog.call();
        dog.eat();
    }
}

2.2.2.4 IOC实现原理

容器的数据结构: map 集合-------K-V Map<K,V> key=bean中的ID, value=实例化的对象
程序执行过程:

1. 指定配置文件的名称.------String resource = “xxxxx.xml”;
2. 当Spring容器加载配置文件时.当按照顺序执行bean标签时,开始创建对象.
3. Spring通过bean标签中的class属性获取类型的路径,之后通过反射机制,实例化对象(必须有无参构造,含参构造会脱离框架的真正意义,找参递参令人头大烦躁)---------- ApplicationContext context =new ClassPathXmlApplicationContext(resource);
4. bean中的Id当做Map中的key, 将实例化的对象保存到Map中,当做value. 至此Spring容器启动成功!!!
5. 当用户需要获取对象时,可以通过key/或者类型 获取对象.

3 Spring注解开发

背景:如果是2010年,那么还需要对xml配置文件有所了解,但是引入springboot之后,基本不需要使用xml配置文件了,一般都使用注解开发.

3.1 编辑配置类

效果: 和配置文件类似
注解作用: 标识/标记
注解1: @Configuration -----声明是配置类
注解2: @Bean -----声明对象交给Spring 容器管理
注解3: @ComponentScan(“com.jt.demo3”) //包扫描注解: 让spring注解生效!!!
Configuration 配置
Bean 豆荚 特指Spring 容器管理的对象
Component 组件 Scan扫描 ComponentScan 包扫描

package com.jt.demo3;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration  //标识当前类是配置类
@ComponentScan("com.jt.demo3")  //包扫描注解: 让spring注解生效!!!
public class SpringConfig {
    //作用: 和配置文件类似,管理对象!!!
    /**
     * IOC-写法
     *  1.@Bean 告诉Spring容器,当前方法的名称,为Map中的key
     *    返回值是Map中的value.
     *  2.特殊用法:
     *      常规条件下,Spring通过反射实例化对象.
     *      也可以由用户自己new的方式创建
     * @return 返回对象
     */
    @Bean
    public Dog dog(){
        return new Dog();
    }
}

3.2 编辑测试类

package com.jt.demo3;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class User {
    public static void main(String[] args) {
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        Dog dog = context.getBean(Dog.class);
        dog.call();
        dog.eat();
    }
}
//Annotation 注解 Config 配置  Application 申请   Context 环境
//AnnotationConfigApplicationContext 申请注解配置环境

3.3 Spring常用注解

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(1) //可以利用order关键字 实现AOP的排序 数字越小越先执行.
25. @ResponseBody 将返回的数据转化为JSON串, 如果是字符串本身 原数据返回
26. @RequestMapping("/hello") 实现浏览器的请求路径与方法的映射
27. @PathVariable restFul结构,接收参数的注解.
28. @GetMapping("") 只能接收GET请求类型
29. @DeleteMapping("") 只能接收DELETE请求类型
30. @PostMapping("") 只能接收POST请求类型
31. @PutMapping("") 只能接收PUT请求类型
32. @RestController 表示Controller类,同时要求返回值为JSON
33. @CrossOrigin 允许跨域访问
34. @RequestBody 参数接收时,将JSON串转化为java对象 json中的key与对象的属性一致.
35. @Data lombok动态生成get/set/toString/equals/hashcode等方法
36. @Accessors 控制是否开启链式加载结构
37. @NoArgsConstructor 生成无参构造方法
38. @AllArgsConstructor 生成全参构造方法
39. @Mapper mybatis将当前的接口交给Spring容器管理. Map<类名小写,JDK动态代理对象>
40. @SpringBootTest 该注解的作用在进行代码测试时启动spring容器,之后动态的获取对象 注意包路径 主启动类的同包及子包中.
41. @Param Mybatis中将参数封装为Map集合. @Param(“maxAge”) int maxAge
42. @Alias Mybatis中定义对象的别名 @Alias(“User”)
43. @MapperScan Mybatis中扫描指定包路径的接口 为其创建代理对象.
44. @Insert Mybatis 新增操作注解
45. @Update Mybatis 修改操作注解
46. @Delete Mybatis 删除操作注解
47. @Select Mybatis 查询操作注解
48. @Transactional Spring中用来控制事务
49. @RestControllerAdvice Controller层的全局异常处理
50. @ExceptionHandler 按照某种异常类型进行拦截
51. @TableName(“item_cat”) MybatisPlus注解POJO与数据表绑定 注意表名
52. @TableId(type = IdType.AUTO) MybatisPlus注解 标识主键/主键自增
53. @TableField(exist = false) MybatisPlus注解 标识属性是否存在,及名称是否一致

3.3.1 Spring中的单例和多例问题

3.3.1.1 概念说明

单例对象: Spring中保存一份对象.
多例对象: Spring容器负责创建多次对象. 内存中对象多份.

3.3.1.1 单例/多例测试

注解:
单例@Scope(“singleton”) 默认选项
多例@Scope(“prototype”)
结论:
1.Spring容器默认条件下,对象都是单例对象. 节省内存空间!!!
2. Spring容器提供了多例对象的方法,一般适用 数据库链接/资源链接等功能…

3.3.1.2 Spring中的懒加载

懒汉式: 用户使用时创建. -------封装构造方法,对象需要时创建且唯一
饿汉式: 不管需不需要都要创建.
懒加载: 默认条件下Spring容器启动时都会实例化对象. 如果用户使用时创建对象,则使用懒加载机制!!!
规则:

1. spring容器启动,对象创建 不是懒加载
2. 当用户使用时创建对象. 是懒加载.

注意事项:
1.如果当前对象是多例模式, 则都是懒加载规则
2.懒加载的控制,只对单例对象有效!!!

package com.jt.demo3;
import org.springframework.context.annotation.*;
@Configuration//配置类
@ComponentScan("com.jt.demo3")//包扫描注解:让spring注解生效
public class SpringConfig {
    @Bean//spring bean对象 value是new Dog(),key是方法名dog
    @Scope("singleton")//单例对象
    //@Scope("prototype")//多例对象 多例默认懒加载 
    @Lazy//懒加载 单例手动懒加载
    public Dog dog(){
        return new Dog();
    }
}

package com.jt.demo3;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class User {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);//spring容器启动,若不开启懒加载,该步骤就会直接调用无参构造创建对象
        context.getBean(Dog.class);//单例模式,开启懒加载此步骤会创建对象
        context.getBean(Dog.class);//不再创建
        Dog dog = context.getBean(Dog.class);//不再创建
        //保存对象地址,地址指向对象 通过对象调用功能属性
        dog.call();
        dog.eat();
    }
}