Spring学习笔记

最新推荐文章于 2024-08-12 16:47:32 发布
最新推荐文章于 2024-08-12 16:47:32 发布
阅读量137 收藏
点赞数
分类专栏： Spring 全家桶 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AO_TAO/article/details/116518120
版权

目录

一、IOC开发

1.IOC介绍（百度百科）

6.纯注解开发

二、AOP 开发

1.AOP介绍（百度百科）

2.AOP底层原理

3.AOP(JDK 动态代理)

4.AOP (术语)

5.AOP 操作（准备工作）

6.AOP 操作（AspectJ注解）

7.AOP 操作（AspectJ配置文件）

一、IOC开发

1.IOC介绍（百度百科）

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

6.纯注解开发

(1) 创建配置类，替代xml配置文件

创建config包，包里放入SpringConfig类

package com.aotao.config;

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

@Configuration //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.aotao"})
public class SpringConfig {
}

(2) 编写测试类

package com.aotao.config;

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

@Configuration //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.aotao"})
public class SpringConfig {

}

(3）加载测试类

public static void testService2(){
        //1.加载spring配置文件
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);

        //2.获取配置创建的对象
        UserService1 userService1 = context.getBean("userService1", UserService1.class);

        System.out.println(userService1);
        userService1.add();
    }

二、AOP 开发

1.AOP介绍（百度百科）

(1) 什么是AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

简答来说就是不通过修改源代码方式添加新的功能，即在主干功能中添加indeed功能

 

2.AOP底层原理

(1) AOP底层使用动态代理

第一种 有接口情况，使用JDK动态代理

  • 创建UserDao接口实现类代理对象

第二种 没有接口情况，使用CGLIB动态代理

  • 创建当前子类的代理对象

 

3.AOP(JDK 动态代理)

(1) 使用JDK动态代理，使用Proxy类里面的方法创建代理对象

调用newProxyInstance方法

方法有三个参数：

第一个参数，类加载器

第二个参数，增强方法所在的类，这个类实现的接口，支持多个接口

第三个参数，实现这个接口InvocationHandler，创建代理对象，写增强方法

(2) 编写JDK动态代理代码

1 创建接口UserDao，定义方法

public interface UserDao {
    public int add(int a,int b);
    
    public String update(String id);
}

2 创建接口实现类UserDaoImpl，实现方法

public class UserDaoImpl implements UserDao{
    public int add(int a, int b) {
        return a+b;
    }

    public String update(String id) {
        return id;
    }
}

3 使用Proxy类创建接口代理对象JDKProxy，底层原理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//
//
//            }
//        });
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int add = dao.add(1, 2);
        System.out.println("Result:"+add);
    }
}

class UserDaoProxy implements InvocationHandler {

    //1 把创建的是谁的代理对象，把谁传递过来，这里的谁就是UserDaoImpl
    //有参数构造传递
    private Object obj;
    public UserDaoProxy(Object obj){
        this.obj = obj;
    }

    //增强逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //方法之前
        System.out.println("方法之前执行……["+method.getName()+"] :传递的参数……"+ Arrays.toString(args));

        //被增强的方法执行
        Object res = method.invoke(obj, args);

        //方法之后
        System.out.println("方法之后执行……"+obj);

        return res;
    }
}

 

4.AOP (术语)

1 连接点

类里面哪些方法可以被增强，这些方法称为连接点。

2 切入点

实际被真正增强的方法，成为切入点

3 通知 (增强)

（1）实际被增强的逻辑部分被称为通知（增强）

（2）通知有多种类型

  • 前置通知（方法执行之前执行）
  • 后置通知（方法执行之后执行）
  • 环绕通知（方法执行之前和之后都会执行）
  • 异常通知（方法出现异常会出现）
  • 最终通知（类似finally）

4 切面

切面是一个动作

  • 把通知应用到切入点过程

 

5.AOP 操作（准备工作）

(1) Spring框架一般基于AspectJ实现AOP操作

1 什么是AspectJ

  • AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作

 (2) 基于AspectJ实现AOP操作

  • 基于xml配置文件
  • 基于注解方式实现

(3) 在项目工程里面引入AOP相关依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjtools -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.8.9</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

(4) 切入点表达式

  • 切入点表达式的作用：知道对哪个类里面的哪个方法进行增强
  • 语法结构：execution( [权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]) )

举例1：对com.aotao.dao.BookDao类里面的add方法进行增强

execution(*com.aotao.dao.BookDao.add(..))

举例2：对com.aotao.dao.BookDao类里面的所有方法进行增强

execution(*com.aotao.dao.BookDao.*(..))

举例2：对com.aotao.dao包里面的所有类所有方法进行增强

execution(*com.aotao.dao.*.*(..))

 

6.AOP 操作（AspectJ注解）

(1) 创建类，在类里面定义方法

//被增强的类
public class User {
    public void add(){
        System.out.println("add.........");
    }
}

(2) 创建增强类（编写增强逻辑）

在增强类里面创建方法，让不同方法代表不同通知类型

//增强的类
public class UserProxy {
    //前置通知
    public void before() {
        System.out.println("before>>>>>>");
    }
}

(3) 进行通知的配置

a.在spring配置文件中，开启注解扫描

<?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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    
    <!--开启注解扫描-->
    <context:component-scan base-package="com.aotao.AOP.ano"></context:component-scan>
</beans>

b.使用注解创建User和UserProxy对象

 

c.在增强类上面添加注解@Aspect

d.在spring的配置文件中开启生成代理对象

<!--开启AspectJ生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

(4) 配置不同类型的通知

 a.在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置

//增强的类
@Component
@Aspect
public class UserProxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.aotao.AOP.ano.User.add(..))")
    public void before() {
        System.out.println("before>>>>>>");
    }

    //最终通知
    @After(value = "execution(* com.aotao.AOP.ano.User.add(..))")
    public void after(){
        System.out.println("after>>>>>>>>>");
    }

    //异常通知 当方法有异常执行
    @AfterThrowing(value = "execution(* com.aotao.AOP.ano.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing>>>>>>>>>");
    }

    //返回通知
    @AfterReturning(value = "execution(* com.aotao.AOP.ano.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning>>>>>>>>>");
    }


    //环绕通知
    @Around(value = "execution(* com.aotao.AOP.ano.User.add(..))")
    public void Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前>>>>>>>>>");

        //被增强的方法执行
        proceedingJoinPoint.proceed();

        System.out.println("环绕之后>>>>>>>>>");
    }
}

b.编写测试类TestAop

public class TestAop {
    public static void testAopAnno(){
        ApplicationContext context = new ClassPathXmlApplicationContext("ano.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }

    public static void main(String[] args) {
        testAopAnno();
    }
}

(5) 相同的切入点抽取

    //相同切入点抽取
    @Pointcut(value = "execution(* com.aotao.AOP.ano.User.add(..))")
    public void pointDemo(){
        
    }
    
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "pointDemo()")
    public void before() {
        System.out.println("before>>>>>>");
    }

(6) 有多个增强类对同一个方法进行增强，可以设置增强类的优先级

a.在增强类上面添加注解@Order(数字类型值) 数值越小优先级越高

@Component
@Aspect
@Order(1)
public class UserProxy
@Component
@Aspect
@Order(3)
public class PersonProxy

 

(7) 使用完全注解开发

创建配置类，不需要创建xml配置文件

@Configuration
@ComponentScan(basePackages = {"com.aotao.Aop"}) //开启组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true) //开启AspectJ生成代理对象
public class ConfigAop {}

 

7.AOP 操作（AspectJ配置文件）

(1) 创建两个类，增强类和被增强类，创建方法

public class Book {
    public void buy() {
        System.out.println("buy>>>>>>>>>");
    }
}
public class BookProxy {
    public void before() {
        System.out.println("before>>>>>>>>>");
    }
}

(2) 在spring配置文件中创建两个类对象

<!--创建对象-->
<bean id="book" class="com.aotao.AOP.xml.Book"></bean>
<bean id="bookProxy" class="com.aotao.AOP.xml.BookProxy"></bean>

(3) 在spring配置文件中配置切入点

    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.aotao.AOP.xml.Book.buy(..))"/>
        
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--配置增强作用在具体方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>

(4) 完整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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd
                            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--创建对象-->
    <bean id="book" class="com.aotao.AOP.xml.Book"></bean>
    <bean id="bookProxy" class="com.aotao.AOP.xml.BookProxy"></bean>

    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.aotao.AOP.xml.Book.buy(..))"/>

        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--配置增强作用在具体方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>
</beans>

AOP就完成了

AO_TAO
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javaSpring学习笔记
03-12
“Java Spring学习笔记”是一份宝贵的资源，专门为想要学习和掌握Java Spring框架的开发者而设计。这份学习笔记提供了详细而系统的教程和实践指南，帮助初学者快速入门，并带领已经有一定经验的开发者深入理解和应用...
什么是ioc
sharesb的博客
03-07 6777
1.什么叫ioc （1）ioc叫做控制反转，是面向对象的一种设计方式， （2）把对象的创建和对象之间的调用过程，交给spring管理。 （3）目的：为了使耦合度降低 （耦合度：在一个类中，我想调用另一个类的方法，就必须new另一个类，这样耦合度太高了，如果我想修改另一个类的位置，就会影响到我这一个类） 在一个类中，我想调用另一个类的方法，不必生成这个类的实例，直接从spring获取，就叫ioc。 之前做的入门案例就是ioc的实现 2..ioc的底层原理 （1）工厂模式 降低service和
浅谈IOC
qq_21704131的博客
03-30 150
什么是IOC? 百度百科介绍：控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对...
spring 学习笔记
05-08
下面将根据“spring 学习笔记”的主题，对Spring框架进行深入的探讨。 一、依赖注入（DI） 依赖注入是Spring的核心功能，它允许对象之间的依赖关系在运行时动态地管理和配置，而不是在代码中硬编码。这样可以提高...
Spring学习笔记 自我总结
11-02
spring学习笔记
spring学习笔记
02-07
本笔记是spring4的，所有内容亲测，方便初学者学习之用。
Spring学习笔记.zip
03-18
根据提供的压缩包文件名，我们可以推测这是一个逐步学习Spring的系列笔记。从"Spring_day1"开始，可能涵盖了Spring的基础概念、环境搭建和基本配置。"Spring_day2"可能涉及了依赖注入和AOP的深入讲解。"Spring_day3...
Java面试篇（JVM相关专题）
聂可以的博客
08-09 2672
Java面试篇（JVM相关专题）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 308
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 278
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
软件测试需要具备的基础知识【功能测试】---后端知识（三）
最新发布
yang_xs的博客
08-12 812
为了更好的学习软件测试的相关技能，需要具备一定的基础知识。需要学习的基础知识包括：1、计算机基础2、前端知识3、后端知识4、软件测试理论后期分四篇文章进行编写，这是第三篇CS架构BS架构效率：c/s效率高，某些内容已经安装在系统中了，b/s每次都要加载最新的数据升级：b/s无缝升级；c/s删除老版本再安装新版本安全：c/s更安全，需要安装、注册、登录；b/s有浏览器即可使用，安全程度低开发成本：b/s成本低；c/s需要不同的系统要不同的开发人员，成本高。
集合（1）
supercool7的博客
08-12 446
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
反射和注解
supercool7的博客
08-08 275
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
m0_75257168的博客
08-10 353
可以同名，但参数列表不能相同（有参无参构造）
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 440
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 296
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
【智能排班系统】SpringBoot整合邮件发送服务
记录一名在读研究生的学习笔记、感悟、开发产物
08-12 282
本文档指导如何配置Spring Boot应用以通过QQ邮箱发送邮件。首先，用户需登录QQ邮箱并开启SMTP服务以获取授权码。随后，在Spring Boot项目中，通过`application.yml`配置文件指定SMTP服务器的地址、端口及认证信息等参数。此外，还介绍了如何创建一个配置类`MailConfig`来读取这些配置，并使用Lombok简化getter和setter方法。为了封装邮件发送所需的属性，文档还提供了`EmailDto`类。
DSL domain specific language of Kola
AK15221736052的博客
08-08 746
Kola 从 SmartBear 的 PactFlow, Spring clout Contract, Spock, Karate 等前辈上得到很多参考和灵感；直接用 ApiHug 上下文的 api 可以有更丰富的上下文， 关于request, response 的定义， path, 参数， 校验规则。但是 BDD 的表达方式，真的是太好了，兼顾程序世界的结构化，和非程序世界的通俗易懂；更不用说， 测试界的基石: Junit5, TestNG, AssertJ 等基础框架；在 ApiHug 上下文，
基于vue框架的NBA球星管理系统1878g（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
08-12 834
随着互联网的普及和体育产业的蓬勃发展，篮球运动在全球范围内拥有庞大的粉丝群体，NBA（美国职业篮球联赛）作为其中的佼佼者，其球星更是备受关注。传统的球星信息管理方式往往依赖于纸质文档或简单的电子表格，这种方式不仅效率低下，难以实现数据的即时更新与共享，也无法满足球迷和媒体对球星信息深度挖掘的需求。因此，开发一套基于Vue框架的NBA球星管理系统，通过信息化手段整合球星信息，实现数据的快速录入、存储、查询与分析，对于提升管理效率、满足用户需求具有重要意义。，处理前端请求并提供业务逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值