Spring学习

最新推荐文章于 2025-03-19 11:46:03 发布

寂寞笙歌凉

最新推荐文章于 2025-03-19 11:46:03 发布

阅读量196

点赞数

文章标签： spring java intellij-idea

本文链接：https://blog.youkuaiyun.com/qq_43606345/article/details/124338503

版权

Spring

基础

SpringBoot
- 一个快速开发的脚手架
- 基于SpringBoot可以快速开发单个微服务
- 约定大于配置
SpringCloud
- 基于SpringBoot实现

Spring和SpringMVC是学习SpringBoot的前提！

导入依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>

初识IOC

实践

1.写一个Hello.class

public class Hello {
    public String name;

    public String getName() {
        return name;
    }

    /**
     * 必须要有set方法
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("Hello" + name);
    }
}

2.配置类到beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--使用spring来创建对象，在spring这些都成为Bean
    bean = 对象  相当于new Hello()
    id = 变量名
    class = new 的对象
    property相当于给对象中的属性设置一个值
    -->
    <bean id="hello" class="com.yangtuo.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>
</beans>

3.新建测试类MyTest.class

public class MyTest {
    public static void main(String[] args) {
        //获取spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //对象现在都在spring中管理，要使用，直接去里面取出来即可
        Hello hello = (Hello) context.getBean("hello");
        hello.show();
    }
}

控制反转

控制：谁来控制对象的创建
反转：程序变成被动的接收对象
依赖注入：使用set方法进行注入

IOC创建对象的方式

1.使用无参构造创建对象，默认

2.假设需要使用有参构造创建对象

1.下标赋值

<bean id="user" class="com.yangtuo.pojo.User">
	<constructor-arg index="0" value="jjn"/>
</bean>

2.类型

3.参数名

Bean自动装配

环境搭建：一个人有两只狗

原始方法

	<bean id="cat" class="com.yangtuo.pojo.Cat"/>
    <bean id="dog" class="com.yangtuo.pojo.Dog"/>
    <bean id="people" class="com.yangtuo.pojo.People">
        <property name="name" value="jjn"/>
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>

ByName自动装配

<!-- 会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid -->
<bean id="people" class="com.yangtuo.pojo.People" autowire="byName">
        <property name="name" value="jjn"/>
    </bean>

ByType自动装配

<!-- 会自动查找和自己对象属性类型相同的bean -->
    <bean id="people" class="com.yangtuo.pojo.People" autowire="byType">
        <property name="name" value="jjn"/>
    </bean>

小结：

在byname时，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
在bytype时，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性类型一致

*使用注解实现自动装配

jdk1.5支持注解，Spring2.5开始支持注解

使用注解须知：
- 导入约束 context约束
- 配置注解的支持 context:annotation-config/

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

1.@autowired

直接在属性上使用即可，也可以在set方法上使用

甚至可以省略set方法，前提是你这个自动装配的属性在ioc容器中存在，且符合bytype

autowired先通过bytype判断，若有多个beantype相同，再通过id名字判断，若没有符合的会报错

也可以结合@Qualifier使用，用来指定名字

@Autowired
@Qualifier(value = "cat2")//xml中有两个类型都为Cat的bean，指定id为cat2的bean
private Cat cat;

科普：

@Nullable  字段标记了这个注解，说明这个字段可以为null

2.@Resourse

先通过byname判断，若没有符合的name，再通过type判断，若多个type相同，则会报错

但是resource可以指定name

@Resource(name = "cat222")
private Cat cat;

使用注解开发

先导：要使用注解，一定要导入aop的包，并且导入context约束，提供直接支持（xml头部）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tIqlIBcO-1650592698251)(C:\Users\角儿是只羊驼\AppData\Roaming\Typora\typora-user-images\image-20220421102712976.png)]

1.bean

就是bean自动装配

2.属性如何注入@Component

@Component 组件，放在类上，表示这个类被spring托管

 <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.yangtuo.pojo"/>

在类中可以配合@Value使用

//等价于在xml中<bean id="user" class="com.yangtuo.pojo.User"/>
@Component
public class User {
    //等价于<property name="name" value="jjn"/>
    @Value("jjn")
    public String name;
}

3.衍生的注解

@Component 有几个衍生注解，在web开发中，会按照mvc三层架构分层

dao[@Repository]
service[@Service]
controller[@Controller]

这四个注解都一样，都是代表将某个类注入到Spring中，装配Bean

4.作用域

@Component
//可以选择单例模式、原型模式
@Scope("singleton")
public class User {
    //等价于<property name="name" value="jjn"/>
    @Value("jjn")
    public String name;
}

5.小结

xml与注解：

xml更万能，适用于任何场合，维护简单方便
注解不是自己的类使用不了，维护相对复杂

最佳实践：xml用来管理bean，注解负责完成属性的注入

注意：必须让注解生效，开启注解支持

使用Java的config实现配置

实践

完全不使用xml配置，全权交给java做，JavaConfig是Spring的一个子项目，在Spring4后，它成为一个核心功能

1.建一个User类，加上注解@Component和@Value

@Component
public class User {

    @Value("jjn")
    private String name;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2.建一个MyConfig类，用来以java形式配置，使用@Configuration和@Bean配合注册bean

//这个也会Spring容器托管，注册到容器中，因为它本来就是一个@Component，@Configuration代表是一个配置类
//与之前写的beans.xml相同
@Configuration
//可以指定需要扫描的包
@ComponentScan("com.yangtuo.pojo")
//可以引入其他配置类
@Import(MyConfig2.class)
public class MyConfig {
    //方法名，相当于bean标签中的id属性
    //返回值，相当于bean标签中的class属性
    @Bean
    public User getUser(){
        return new User();
    }
}

3.建一个测试类MyTest

public class MyTset {
    public static void main(String[] args) {
        //如果完全使用配置类方式去做，我们就只能通过AnnotationConfig方法获取容器，通过配置类的class加载
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        User getUser = context.getBean("getUser", User.class);
        System.out.println(getUser.getName());
    }
}

代理模式

是Spring AOP的底层实现，分为静态代理和动态代理

静态代理

角色分析：

抽象角色：一般通过接口或抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，之后，我们一般会做一些附属操作
客户：访问代理对象的人

好处：

- 可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
- 公共业务交给代理角色，实现业务的分工
- 公共业务发生扩展的时候，方便集中管理

缺点：

- 一个真实角色就会产生一个代理角色，代码翻倍，开发效率变低

1.接口定义

//租房接口
public interface Rent {
    public void rent();
}

2.真实角色

//房东
public class Host implements Rent{
    
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

3.代理角色

//代理
public class Proxy {
    //先获取房东
    private Host host;
    public Proxy() {
    }
    public Proxy(Host host) {
        this.host = host;
    }
    //帮房东租房子
    public void rent(){
        host.rent();
        seeHouse();
        charge();
    }

    //看房
    public void seeHouse(){
        System.out.println("中介带你看房");
    }

    //收费 
    public void charge(){
        System.out.println("收费");
    }
}

4.客户端访问代理角色

//我
public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        //中介帮房东租房子，但是，代理一般会有一些附属操作
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

动态代理

底层：反射机制

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，通过反射机制
动态代理分为两大类：1.基于接口；2.基于类
- 基于接口——JDK动态代理
- 基于类——cglib
- java字节码——javassist

需要了解两个类：Proxy：代理，InvocationHandler：调用处理程序

InvocationHandler

是一个接口，只有一个invoke方法

静态代理VS动态代理（增删改查四个方法）

1.定义接口，抽象角色

public interface database {
    public void add();
    public void delete();
    public void update();
    public void query();
}

2.实现接口，真实角色

public class databaseImpl implements database{
    @Override
    public void add() {
        System.out.println("增");
    }

    @Override
    public void delete() {
        System.out.println("删");
    }

    @Override
    public void update() {
        System.out.println("改");
    }

    @Override
    public void query() {
        System.out.println("查");
    }
}

3.静态方法代理类

public class Proxy {
	//先获取代理对象
    databaseImpl database = new databaseImpl();

    public Proxy() {
    }

    public Proxy(databaseImpl database) {
        this.database = database;
    }

    public void add(){
        log("add");
        database.add();
    }
    public void delete(){
        log("delete");
        database.delete();
    }
    public void update(){
        log("update");
        database.update();
    }
    public void query(){
        log("query");
        database.query();
    }

    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

4.客户端访问代理角色

Proxy proxy1 = new Proxy(database);
        proxy1.add();

5.动态方法代理

public class ProxyInvocationHandler implements InvocationHandler {
	//丢给我啥类型都行，被代理的对象
    private Object target;
    public void setTarget(Object target){
        this.target = target;
    }
	//固定写法，生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(), this);
    }
    //处理代理实例，并返回结果
    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, objects);
        return result;
    }

    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

6.客户端访问代理

//真实角色
        databaseImpl database = new databaseImpl();
        //代理角色，不存在，动态生成
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //设置要代理的对象
        pih.setTarget(database);
        //动态生成代理类
        database proxy = (database) pih.getProxy();
        //代理类调用方法
        proxy.delete();

动态代理的好处：

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务交给代理角色，实现业务的分工
公共业务发生扩展的时候，方便集中管理
一个动态代理代理的是一个接口，一般就是对应的一类业务
一个动态代理类可以代理多个类，只要是实现了同一个接口即可

初识AOP

1.导包

<dependencies>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

方式一：使用Spring的API接口

1.创建接口

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void query();
}

2.实现接口

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("删除了一个用户");
    }

    @Override
    public void update() {
        System.out.println("更新了一个用户");
    }

    @Override
    public void query() {
        System.out.println("查询一个用户");
    }
}

3.实现前、后日志，实现了Spring自带的接口来完成

public class Log implements MethodBeforeAdvice {
    //method:要执行的目标对象的方法
    //args：参数
    //target：目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

public class AfterLog implements AfterReturningAdvice {
    //returnValue:返回值
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }

4.写入配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.yangtuo.service.UserServiceImpl"/>
    <bean id="log" class="com.yangtuo.log.Log"/>
    <bean id="afterLog" class="com.yangtuo.log.AfterLog"/>

    <!--方式一：使用spring原生api接口-->
    <!--配置aop:需要导入aop的约束-->
    <aop:config>
    <!--切入点,expression:表达式，excution(要执行的位置)-->
    <aop:pointcut id="pointcut" expression="execution(* com.yangtuo.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

5.测试

public class MyTset {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理代理的是接口
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

方式二：自定义来实现AOP(主要是切面定义)

1,2不变

3.将需要作出的更改写在一个类里，即自定义一个切面

public class DiyPointCut {
    public void before(){
        System.out.println("方法执行前");
    }
    public void after(){
        System.out.println("方法执行后");
    }
}

4.写入配置文件

<!--    方式二：自定义类-->
    <bean id="diy" class="com.yangtuo.diy.DiyPointCut"/>
    <aop:config>
<!--        自定义切面，ref：要引用的类-->
        <aop:aspect ref="diy">
<!--            切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.yangtuo.service.UserServiceImpl.*(..))"/>
<!--            通知,就是切面中的方法，并设置该方法与切入点的位置关系，before，after啥的-->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>

        </aop:aspect>
    </aop:config>

5.测试类不变

方式三：使用注解实现

1,2不变

3.应用注解写切面

/**
 * 使用注解方式实现AOP
 */
@Aspect//标注这个类是一个切面
public class AnnotationPointCut {

    @Before("execution(* com.yangtuo.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("===方法执行前===");
    }
    
    @After("execution(* com.yangtuo.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("===方法执行后===");
    }
    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.yangtuo.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        Object proceed = jp.proceed();
        System.out.println("===方法执行后===");
    }
}

4.将切面类注册到bean中,一定要开启自动代理

<!--    方式三：使用注解-->
    <bean id="annotationPointCut" class="com.yangtuo.diy.AnnotationPointCut"/>
<!--    开启自动代理-->
    <aop:aspectj-autoproxy/>

5.测试类不变