Spring框架

最新推荐文章于 2024-05-15 13:45:01 发布

Cindy的雨伞

最新推荐文章于 2024-05-15 13:45:01 发布

阅读量93

点赞数

文章标签： spring java spring boot

本文链接：https://blog.csdn.net/weixin_51518228/article/details/121952192

版权

Spring 注解开发

1.1 关于Spring注解开发的说明

大约在2015年以前框架的开发需要大量的xml配置文件。导致项目配置比较臃肿,开发效率略低. 但是项目整合时的报错概率很高. Spring与时俱进从3开始逐步演化为注解开发. 到了SpringBoot框架的诞生,标志着进入了全注解时代.

1.2 创建springdemo3_anno项目

请添加图片描述

1.3 注解开发的步骤

1.3.1 编辑User类

package com.jt.demo;

public class User {

    public void say(){
        System.out.println("使用全注解的方式管理对象");
    }
}

1.3.2 编辑配置类

说明: 原始的开发使用xxx.xml文件用来管理对象, 现在都使用java类的形式当作配置文件则将该java类称之为配置类.

package com.jt.config;

import com.jt.demo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration //将当前类标识为配置类
public class SpringConfig {//xml
    /**
     *  1.xml形式
     *      <bean id="user" class="com.jt.demo.User"></bean>
     *  2.注解形式
     *     Map集合的结构 Map<方法名,方法的返回值>
     *     @Bean 将方法的返回值,交给Spring容器管理.
     */
    @Bean
    public User user(){

        return new User(); //相当于xml反射机制创建对象
    }
}

1.3.3 编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {

    //利用注解的方式管理对象
    @Test
    public void testDemo1(){
        //1.利用注解的方式启动spring容器
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //2. 从容器中获取对象
        User user = context.getBean(User.class);
        //3. 对象调用方法
        user.say();
    }
}

1.4 关于IOC总结

什么是IOC 由Spring容器管理对象的生命周期,降低代码耦合性
xml配置文件管理对象
1.准备xxx.xml配置文件 2.准备bean标签
3.spring容器管理对象
ApplicationContext容器顶级接口
ClassPathXmlApplicationContext 加载配置文件的实现类对象
全注解的方式管理对象
准备配置类 @Configuration + @Bean

要求方法必须有返回值

容器对象
ApplicationContext容器顶级接口
AnnotationConfigApplicationContext

万能语法: 根据当前spring的配置规则,实例化接口对象. 我一般不写这些代码,如果想看也可以通过ApplicationContext 查找指定的实现类.

1.5 Spring创建对象—工厂模式(必会内容)

1.5.1 关于对象管理问题说明

问题: 任意对象都可以通过new的关键字实例化吗?
答案: 当然不是, 抽象类对象不可以直接实例化.

1.5.2 创建项目springdemo4_factory

请添加图片描述

1.5.3 关于spring中注解说明

@Component 将当前的类,交给Spring容器管理, 对象的创建是由Spring通过反射机制自动创建对象.
@ComponentScan(“com.jt”) 指定扫描的包路径, 可以扫描它的子孙包,用在配置类中

1.5.4 代码结构

请添加图片描述

1.5.5 编辑配置类

package com.jt.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
//准备一个配置类
@Configuration
@ComponentScan("com.jt")
//当spring容器启动时,根据指定的包路径,扫描其子孙包
public class SpringConfig {
}

1.5.6 编辑User类

package com.jt.demo;

import org.springframework.stereotype.Component;
//Spring容器管理  Map<类名首字母小写:user,实例化的对象>
@Component
public class User { //spring容器通过反射机制实例化对象

    public void say(){
        System.out.println("通过@Component注解实例化对象");
    }
}

1.5.7 编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {

    @Test
    public void testDemo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean(User.class);
        user.say();
    }
}

1.5.8 利用工厂模式创建对象(了解)

1.5.8.1 业务说明

Spring中管理的对象,大部分可以通过new/反射进行对象的创建. 但是有些对象由于特殊的原因.不能直接new/实例化.这时需要考虑是否可以通过工厂模式实现.
例如: Calendar 该类是一个抽象类所以不能直接实例化
请添加图片描述

1.5.8.2 创建工厂模式

package com.jt.factory;

import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;

import java.util.Calendar;

/**
 * FactoryBean是Spring提供的接口,spring自动完成调用.获取指定的对象
 * 难点讲解:
 *      1.@Component 标识类 则将该类交给Spring容器管理.
 *      2.Spring中FactoryBean的讲解
 *          如果spring加载的时候遇到FactoryBean接口
 *          则会自动的执行重写的方法getObject/getObjectType
 *      3.工厂模式说明:
 *          Map<Key:calendar,value=Calendar对象></>
 *
 *      核心功能:
 *              1. key: 就是当前类型(如果自己编辑注解以注解为准)
 *              2. value: 调用getObject获取的返回值对象
 *              将上述的数据,交给Spring容器管理
 *      该功能什么时候使用:
 *              1. 某些对象不能直接实例化的.
 *              2. 整合其它第三方框架对象时 经常使用.
 */
@Component("calendar")
public class CalendarFactory implements FactoryBean<Calendar> {

    public CalendarFactory(){
        System.out.println("工厂模式的无参构造");
    }

    //现阶段 大家理解为主. 未来写结构设计的时候,作用很大!!!!!
    //动态执行该方法,获取返回值对象
    @Override
    public Calendar getObject() throws Exception {
        //利用calendar的工具API 实现对象的创建
        return Calendar.getInstance();
    }

    @Override
    public Class<?> getObjectType() {
        //固定写法. 一般直接xxx.class即可
        return Calendar.class;
    }
}

1.5.8.3 编辑测试API

  @Test
    public void testDemo2(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //Calendar calendar = context.getBean(Calendar.class);
        Calendar calendar = (Calendar) context.getBean("calendar");
        System.out.println("获取当前时间:"+calendar.getTime());
        System.out.println("获取年:"+calendar.getWeekYear());
    }

1.6 注解复习

1.@Configuration 标识配置类
2.@Bean 将自己方法的返回值交给Spring容器管理
3.@Component 将该类交给spring容器管理. 通过反射自动实例化对象
4.@ComponentScan(“com.jt”) 包扫描的注解使Spring注解有效

2. Spring框架讲解

2.1 单例和多例

2.1.1 关于单例和多例说明

单例：在内存中只有一份
多例：在内存中可能有多份

2.1.2 创建项目springdemo5_base

请添加图片描述

2.1.2 编辑User类

package com.jt.demo;

import org.springframework.stereotype.Component;

public class User {
    public User(){
        System.out.println("我是无参构造,创建对象");
    }

    public void say(){
        System.out.println("测试对象是单例还是多例");
    }
}

2.1.3 关于单例多例的测试

规则1：Spring默认管理的对象都是单例的。
规则2: 通过@Scope注解,控制对象单例/多例

package com.jt.config;

import com.jt.demo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@Configuration  //标识这是配置类
@ComponentScan("com.jt")
public class SpringConfig {

    @Bean
    @Scope("singleton")     //默认值 单例模式
    //@Scope("prototype")   //      多例模式
    public User user(){
        return new User();
    }
}

2.1.4 编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {


    @Test
    public void testDemo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        User user1 = context.getBean(User.class);
        User user2 = context.getBean(User.class);
        user1.say();
        System.out.println(user1 == user2);//true
    }
}

2.2 懒加载机制

1.2.1 懒加载说明

说明: 如果Spring容器创建,对象立即创建则该加载方式为 “立即加载”, 容器启动创建
如果Spring容器创建,对象在被使用的时候才创建, 则称为"懒加载" 用时才创建

注解: @Lazy 添加表示改为懒加载
测试说明: 主要测试对象中的无参构造什么时候执行!!!

2.2.2 懒加载用法

package com.jt.config;

import com.jt.demo.User;
import org.springframework.context.annotation.*;

@Configuration  //标识这是配置类
@ComponentScan("com.jt")
public class SpringConfig {

    @Bean
    //@Scope("singleton")    //默认值 单例模式
    //@Scope("prototype")    //  多例模式
    @Lazy                    //懒加载
    public User user(){
        return new User();
    }
}

2.2.3 多例与懒加载的关系

说明: 只要对象是多例模式,则都是懒加载!, 在单例模式中控制懒加载才有效.
规则说明:
lazy true lazy false
单例模式: 有效懒加载有效立即加载
多例模式: 无效懒加载无效懒加载

2.2.4 关于lazy 使用场景的说明

场景1: 服务器启动时,如果加载太多的资源,则必然导致服务器启动慢, 适当的将不重要的资源设置为懒加载.
场景2: 有时用户会需要一些特殊的"链接",而这些链接的创建需要很长的时间.可以使用懒加载.

2.3 Spring对象生命周期管理

2.3.1 关于对象生命周期说明

说明: 一个对象从创建到消亡,可以划分为四个阶段. 如果需要对程序进行干预.则可以通过周期方法进行干预. (回调函数/钩子函数/接口回调)
图解说明生命周期函数的作用: 主要作用可以在各个时期对对象进行干预
请添加图片描述

2.3.2 生命周期函方法的使用

package com.jt.demo;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component  //将对象交给Spring容器管理 key=person value:反射对象
public class Person {

    public Person(){
        System.out.println("张三出生了,资质拉满");
    }

    @PostConstruct  //在对象创建之后立即调用
    public void init(){
        System.out.println("张三称为少年奇才");
    }

    //业务方法
    public void doWork(){
        System.out.println("迎娶美人鱼!!!");
    }

    @PreDestroy //对象消亡时 进行调用
    public void destory(){
        System.out.println("销毁:全世界哀悼");
    }
}

2.3.3 测试案例

@Test
    public void testDemo3Init(){
        //容器启动对象创建
        AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        Person person = context.getBean(Person.class);
        person.doWork();
        //将容器关闭
        context.close();
    }

2.3.4 使用注解

@PostConstruct //在对象创建之后立即调用
@PreDestroy //对象消亡时进行调用

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

2.2.1 创建结构

准备User类
准备Dog类
准备Cat类
说明: Dog/Cat向User类进行对象的注入功能.
请添加图片描述

2.2.2 @Autowired注解

说明: 在对象中如果需要使用属性注入.一般使用@Autowired注解.
功能: 可以将Spring容器中的对象,自动注入到属性中.
注入方式:

默认按照类型注入. 如果注入的属性是接口,则自动注入实现类
按照名称注入(key). 一般不用

重要前提: 如果需要依赖注入.则对象必须交给Spring容器管理.

2.2.3 编辑Pet接口

public interface Pet {
    void hello();
}

2.2.4 编辑Cat类

package com.jt.demo;

import org.springframework.stereotype.Component;

@Component //将对象交给spring容器管理 key:cat value:反射Cat对象
public class Cat implements Pet{

    @Override
    public void hello() {
        System.out.println("我是喵喵喵");
    }
}

2.2.5 编辑User类

package com.jt.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component  //将user交给Spring容器管理
public class User {

    //效果: 将当前接口的实现类自动注入
    @Autowired
    private Pet pet;

    public void say(){
        //调用宠物的方法
        pet.hello();
    }
}

2.2.6 编辑配置类

package com.jt.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration            //标识我是配置类
@ComponentScan("com.jt")  //必须添加包路径
public class SpringConfig {

}

2.2.7 编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.demo.User;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

class TestSpring {

    @Test
    public void testDemo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        User user = context.getBean(User.class);
        user.say();
    }

}

2.3 接口多实现的情况说明

2.3.1 代码说明

1.一个接口 2个实现类结构如下
请添加图片描述
猫类：

狗类：请添加图片描述

2.3.2 报错说明

说明: 一个接口应该只有一个实现类,否则spring程序无法选择.
请添加图片描述

2.3.3 解决方案

package com.jt.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component  //将user交给Spring容器管理
public class User {

    //效果: 将当前接口的实现类自动注入
    @Autowired
    @Qualifier("cat") //该注解不能单独使用,必须配合Autowired使用,根据key进行注入
    private Pet pet;  //2选1

    public void say(){
        //调用宠物的方法
        pet.hello();
    }
}

2.3.4 @Resource注解说明

请添加图片描述

2.4 MVC 设计思想

2.4.1 MVC思想说明

经典MVC模式中，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。其中，View的定义比较清晰，就是用户界面。

M: model 业务模型
V: view 用户界面
C: control 控制层

历史说明:
JSP动态页面 html代码 + java代码写到一起 xxx.jsp
不方便后期维护. 页面和业务执行紧紧的绑定在一起耦合性高.
请添加图片描述
小结:

MVC是一种设计思想,编码中降低代码的耦合性.
前端专注于开发页面 view
后端专注于开发后端 model
2者通过control 进行控制

2.4.2 层级代码结构

说明: MVC设计思想,实现了前端和后端的松耦合.但是根据实际的开发情况,很多的业务逻辑比较复杂.如果后端将所有的代码都写到同一个java类中.这样的代码结构很臃肿. 为了很好的实现MVC设计思想.所以后端代码也应该分层.

分层说明:

控制层 Controller 与前端页面交互的. @Controller
业务层 Service 编辑业务逻辑. @Service
持久层 Mapper 实现数据库的相关操作暂时:@Repository
MVC > 三层代码结构!!!

2.5 三层代码结构

2.5.1 编辑Mapper层

编辑mapper接口

package com.jt.mapper;
//面向接口开发
public interface UserMapper {

    void  addUser();
}

编辑MapperImpl

package com.jt.mapper;

import org.springframework.stereotype.Repository;

@Repository //为了让程序员开发有层级的概念
public class UserMapperImpl implements UserMapper{

    @Override
    public void addUser() {
        System.out.println("新增用户AAA");
    }
}

2.5.2 编辑Service层

编辑UserService接口

package com.jt.service;

public interface UserService {

    void addUser();
}

编辑UserServiceImpl

package com.jt.service;

import com.jt.mapper.UserMapper;
import com.jt.mapper.UserMapperImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper; //默认按照类型注入

    @Override
    public void addUser() {
        userMapper.addUser();
    }
}

2.5.3 编辑Controller层

package com.jt.controller;

import com.jt.service.UserService;
import com.jt.service.UserServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

//controller层只有类 不用写接口
@Controller
public class UserController {

    @Autowired
    private UserService userService;

    public void addUser(){
        userService.addUser();
    }
}

2.5.4 编辑配置类

package com.jt.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.jt")
public class SpringConfig {
}

2.5.5 编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.controller.UserController;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {

    @Test
    public void testDemo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        UserController userController = context.getBean(UserController.class);
        userController.addUser();
    }
}

2.6 请谈一下你对IOC/DI的看法(开放)

历史: 传统代码其中的属性对象一般都是通过new关键字手动创建,这样的代码耦合性高,不方便扩展
功能:

IOC: 由Spring容器管理对象的生命周期.
使得对象与对象之间的耦合性降低.
DI是依赖注入. 只有被spring容器管理的对象才可以被依赖注入. 默认的条件下采用类型注入.如果有特殊需求也可以采用名称注入(@Qualifier(“cat”))
Spring中 IOC和DI相互配合,可以极大程度上降低耦合性.

意识:
Spring由于采用了IOC/DI的设计方式,可以整合其它的第三方框架.使得程序的调用"浑然一体"

2.7 @Value注解说明

2.7.1 注解赋值

说明: @Value注解可以直接为基本类型赋值和String类型
问题: 如果像图中赋值,则耦合性依然很高,不通用. 需要优化!!!
请添加图片描述

1.7.2 编辑user.properties

说明: 对象中的属性一般都是业务数据,如果需要为业务数据赋值,则一般采用properties文件更加灵活.
位置: 在resources目录下
请添加图片描述
字符集编码说明:

配置文件内容:

#1.注意事项:  key=value  等号连接  2.中间不要添加多余的空格
#2.说明: windows系统中有环境变量username=系统用户名称,以后写业务数据时,最好绕开关键字username
#3.编码规则: 程序默认读取properties文件时,采用ISO-8859-1编码
user.username=葫芦娃

2.7.3 @value为属性赋值

package com.jt.mapper;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Repository;

@Repository //为了让程序员开发有层级的概念
@PropertySource(value="classpath:/user.properties",encoding = "UTF-8")
//classpath:/  代表resources的根目录
public class UserMapperImpl implements UserMapper{
    //耦合性!!!!
    // 表达式: 固定写法  springel表达式 取值方式 缩写spel表达式
    // 规则:通过key动态获取spring容器中的value
    @Value("${user.username}")
    private String username;

    @Override
    public void addUser() {
        System.out.println("新增用户:"+username);
    }
}