Spring

最新推荐文章于 2024-05-30 11:35:05 发布
最新推荐文章于 2024-05-30 11:35:05 发布
阅读量193 收藏
点赞数
文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OCISLY/article/details/109907669
版权

1、Spring

1.1、简介

  • Spring：春天
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-doXQasGm-1605962607198)(Spring.assets/image-20201111204457769.png)]
  • Spring理念：解决开发的复杂性。但也是一个大杂烩，整合现有的框架！
  • SSH：Struct2 + Spring + Hibernate
  • SSM：SpringMVC + Spring + Mybatis

官网：https://spring.io/projects/spring-boot

官方下载地址：https://repo.spring.io/libs-release-local/org/springframework/spring/

Github：https://github.com/spring-projects/spring-boot

Spring Maven仓库：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

1.2、优点

  • Spring是一个开源的免费框架（容器）！
  • Spring是一个轻量级的、非入侵式的框架！
  • 控制反转（IOC），面向切面编程（AOP）！（重点）
  • 支持事务的处理，对框架整合的支持！

总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

1.3、组成

img

1.4、拓展

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4TIaxznb-1605962607202)(Spring.assets/image-20201112143151090.png)]

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

学习SpringBoot的前提，需要完全掌握Spring及SpringMVC，承上启下

2、IOC理论推导

以前写项目

  1. UserDao 接口

    package com.zheng.dao;

public interface UserDao {
    void getUser();
}

  2. UserDaoImpl 实现类

    package com.zheng.dao;

public class UserDaoImpl implements UserDao{
    public void getUser() {
        System.out.println("default get user data");
    }
}

  3. UserService 业务接口

    package com.zheng.service;

public interface UserService {
    void getUser();
}

  4. UserServiceImpl 业务实现类

    package com.zheng.service;

import com.zheng.dao.UserDao;
import com.zheng.dao.UserDaoImpl;
import com.zheng.dao.UserDaoMysqlImpl;

public class UserServiceImpl implements UserService{

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void getUser() {
        userDao.getUser();
    }
}

Set接口实现

    private UserDao userDao;

	//利用set进行动态实现值的注入！
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

思想：将主动权从程序员手中交给用户，减小程序的耦合性，让程序员注重在业务层

IOC本质：解耦,实现方法是依赖注入（DI）

3、HelloSpring

  1. 创建Hello类

    package com.zheng.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

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

  2. 配置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 id="hello" class="com.zheng.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

</beans>

  3. 创建测试类MyTest2

    import com.zheng.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest2 {
    public static void main(String[] args) {
        //获取Spring的上下文对象！
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

  4. 结果

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pcSps0Y5-1605962607203)(Spring.assets/image-20201112205000194.png)]

3.1、改造以前的项目

  1. 增加配置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">

    <bean id="mysqlImpl" class="com.zheng.dao.UserDaoMysqlImpl"/>
    <bean id="UserServiceImpl" class="com.zheng.service.UserServiceImpl">

        <property name="userDao" ref="mysqlImpl"></property>
    </bean>

</beans>

  2. 修改main函数

    import com.zheng.service.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //获取ApplicationContext，拿到Spring的容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //直接get
        UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");

        userServiceImpl.getUser();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QziqveUY-1605962607205)(Spring.assets/image-20201114100824256.png)]

4、IOC创建对象的方式

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

  2. 使用有参构造创建对象。

    1. 下标赋值

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

    2. 类型

      <bean id="user" class="com.zheng.pojo.User">
    <constructor-arg type="java.lang.String" value="ajax"/>
</bean>

    3. 参数名

      <bean id="user" class="com.zheng.pojo.User">
    <constructor-arg name="name" value="ajax"/>
</bean>

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！

5、Spring配置

5.1、别名

<!--    别名，缩短名称-->
<alias name="user" alias="user2"/>

5.2、Bean的配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rM7wS8Ie-1605962607207)(Spring.assets/image-20201115143441716.png)]

5.3、import

一般用于团队开发使用，将多个配置文件导入合并为一个

6、依赖注入

6.1、构造器注入

前面已经说过了

6.2、Set方式注入【重点】

  • 依赖注入：Set注入！
    • 依赖：bean对象的创建依赖于容器
    • 注入：bean对象中的所有属性，由容器来注入

【环境搭建】

  1. 复杂类型

    package com.zheng.pojo;

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

  2. 真实测试对象

    package com.zheng.pojo;

import java.util.Arrays;
import java.util.List;

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }
}

  3. 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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="student" class="com.zheng.pojo.Student">
        <property name="name" value="ajax"/>
    </bean>
</beans>

  4. 测试类

    import com.zheng.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
    }
}

6.3、拓展方式注入

p命名空间，c命名空间

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--    p命名空间，直接注入属性-->
    <bean id="user" class="com.zheng.pojo.User" p:name="ajax" p:age="19"/>

    <!--c命名空间，构造器注入：construct-args-->
    <bean id="user2" class="com.zheng.pojo.User" c:age="20" c:name="kk"/>
</beans>

测试：

@Test
public void test2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
    User user = context.getBean("user2", User.class);
    System.out.println(user);
}

注意点：p，c不能直接使用，要导入约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

6.4、bean的作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ItuXZBge-1605962607208)(Spring.assets/image-20201118103041289.png)]

  1. 单例模式（Spring默认机制）

    <bean id="accountService" class="com.something.DefaultAccountService"/>

<!-- the following is equivalent, though redundant (singleton scope is the default) -->
<!--以下是等效的，尽管是冗余的（默认情况下是单例作用域）-->
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>

  2. 原型模式：每次从容器get的时候，都会产生新对象

    <!--产生新的对象-->
<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

  3. 其余的request、session、application，这些只能在web开发中使用。

7、Bean的自动装配

  • 自动装配是Spring满足bean依赖一种方式
  • Spring会在上下文中自动寻找，并自动给bean装配属性

在Spring中有三种装配的方式

  1. 在xml中显示的配置
  2. 在java中显示配置
  3. 隐式的自动装配bean【重点】

7.1、测试

环境搭建：一个人有两只宠物。

7.2、ByName自动装配

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

7.3、ByType自动装配

<!--
byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应beanid！
byTame:会自动在容器上下文中查找，和自己对象属性类型相同的bean！
-->
<bean id="people" class="com.zheng.pojo.People" autowire="byType">
    <property name="name" value="aja"/>
</bean>

小结：

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

7.4、使用注解实现自动装配

The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.

  1. 导入约束
  2. 配置注解的支持：< 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>

@Autowired：自动装配

@Nullable：允许为空

测试代码

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
}

@Resource：java的自动装配

只使用@Autowired

8、使用注解开发

在Spring4之后，要使用注解开发，必须要保证aop的包导入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6ElvpGNw-1605962607209)(Spring.assets/image-20201118203215355.png)]

  1. bean

  2. 属性如何注入

    //等价于<bean id="user" class="com.zheng.pojo.User"/>
@Component
public class User {
    @Value("asd")
    public String name;
}

  3. 衍生的注解

    @Component有几个衍生注解，功能一样，注册到Spring，装配bean

    • dao【@Repository】
    • service【@Service】
    • controller【@Controller】

  4. 自动装配

    @Autowired：自动装配

    @Nullable：允许为空

    @Resource：java的自动装配

  5. 作用域

    @Scope("prototype")
@Component
public class User {
    @Value("asd")
    public String name;
}

  6. 小结

    xml与注解：

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

    xml与注解最佳实践：

    • xml用来管理bean
    • 注解只负责完成属性的注入
    • 需要注意：必须让注解生效，开启注解的支持
    <!--    扫描包-->
<context:component-scan base-package="com.zheng"/>
<context:annotation-config/>

9、使用java的方式配置Spring

完全不需要xml配置文件，在SpringBoot随处可见，纯注解

实体类：

package com.zheng.pojo;

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

@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }
    @Value("ajax")
    public void setName(String name) {
        this.name = name;
    }

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

配置类：

package com.zheng.config;

import com.zheng.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    //id
    @Bean
    public User user(){
        return new User();
    }
}

测试类：

import com.zheng.config.AppConfig;
import com.zheng.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        User getUser = (User) context.getBean("user");
        System.out.println(getUser.getName());
    }
}

10、代理模式

SpringAOP的底层：代理模式【SpringAOP和SpringMVC】

代理模式的分类：

  • 静态代理
  • 动态代理

10.1、静态代理

代码步骤：

  1. 接口

    package com.zheng.demo01;

public interface Rent {
    public void rent();
}

  2. 真实角色

    package com.zheng.demo01;

public class Host implements Rent{


    public void rent() {
        System.out.println("房东要出租房子");
    }
}

  3. 代理角色

    package com.zheng.demo01;

public class Proxy {
    private Host host;

    public Proxy(){

    }

    public Proxy(Host host){
        this.host = host;
    }

    public void rent(){
        host.rent();
    }

    //...
}

  4. 客户端访问代理角色

    package com.zheng.demo01;

public class Client {
    public static void main(String[] args) {
        Host host = new Host();

        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

10.2、代理（切面编程）

10.3、动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的
  • 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
    • 基于接口—JDK动态代理
    • 基于类：cglib
    • java字节码实现：javassist

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

11、AOP

【重点】使用AOP织入，需要导入一个依赖包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
    <scope>runtime</scope>
</dependency>

什么是AOP

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

Aop在Spring中的作用

提供声明式事务；允许用户自定义切面

以下名词需要了解下：

  • 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
  • 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
  • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
  • 目标（Target）：被通知对象。
  • 代理（Proxy）：向目标对象应用通知之后创建的对象。
  • 切入点（PointCut）：切面通知 执行的 “地点”的定义。
  • 连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

即 Aop 在 不改变原有代码的情况下 , 去增加新的功能 .

使用Spring实现Aop

【重点】使用AOP织入，需要导入一个依赖包！

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

第一种方式

通过 Spring API 实现

首先编写我们的业务接口和实现类

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

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 search() {
    System.out.println("查询用户");
}

}

然后去写我们的增强类 , 我们编写两个 , 一个前置增强 一个后置增强

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

public class AfterLog implements AfterReturningAdvice {
    //returnValue 返回值
    //method被调用的方法
    //args 被调用的方法的对象的参数
    //target 被调用的目标对象
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + target.getClass().getName()
        +"的"+method.getName()+"方法,"
        +"返回值："+returnValue);
    }
}

最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .

<?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
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <!--注册bean-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>
    <!--aop的配置-->
    <aop:config>
        <!--切入点  expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.search();
    }
}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解这一块 .

Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .

第二种方式

自定义类来实现Aop

目标业务类不变依旧是userServiceImpl

第一步 : 写我们自己的一个切入类

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

去spring中配置

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.kuang.config.DiyPointcut"/>
<!--aop的配置-->
<aop:config>
    <!--第二种方式：使用AOP的标签实现-->
    <aop:aspect ref="diy">
        <aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <aop:before pointcut-ref="diyPonitcut" method="before"/>
        <aop:after pointcut-ref="diyPonitcut" method="after"/>
    </aop:aspect>
</aop:config>

测试：

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

第三种方式

使用注解实现

第一步：编写一个注解实现的增强类

package com.kuang.config;
 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
 
@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("---------方法执行前---------");
    }
 
    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("---------方法执行后---------");
    }
 
    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:"+jp.getSignature());
        //执行目标方法proceed
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

第二步：在Spring配置文件中，注册bean，并增加支持注解的配置

<!--第三种方式:注解实现-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

aop:aspectj-autoproxy：说明

通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了
 
<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy  poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。
洛慕晨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 8万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
spring6pdf详细讲解
09-18
spring6pdf详细讲解
Spring之IOC
m0_67864917的博客
08-05 151
安全技术方面：Shiro springSecurity数据库层面：hibernate/mybatis SpringDataJpa消息中间件：activityMQ、RabbitMQ、kaffka spring..MQSpring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。3.1 id：在容器中查找Bean的id(唯一、且不能以/开头)3.2 class：bean的完整类名。...
springIOC 概述理解
wangZY的博客
03-06 328
Spring概述 核心容器 IOC DI 控制反转 用依赖注入的方式实现解耦
Spring Boot面试题（2020最新版）
ThinkWon的博客
02-19 56万+
文章目录概述什么是 Spring Boot？Spring Boot 有哪些优点？Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？配置什么是 JavaConfig？Spring Boot 自动配置原理是什么？你如何理解 Spring Boot 配置加载顺序？什么是 YAML？YAML 配置的优势在哪里 ?Spring Boot 是否可以使用 XML 配置 ?spring boot......
【Spring】一个spring简单实例
一定要站在自己热爱的生活里闪闪发光
05-07 7万+
spring的基础知识就不讲了，直接上代码吧！ 为了方便大家创建文件，先把project的结构放在这 1.新建一个projec，本帖设置的名字为“project-hello”. 2. 新建一个package，这里取名为“com.company.project”. 3. 新建一个class，名为“Hello”。代码为： package com.company.project; public class Hello { private String name; pub.
史上最简单的 SpringCloud 教程 | 终章
热门推荐
方志朋的专栏
04-12 197万+
转载请标明出处： http://blog.csdn.net/forezp/article/details/70148833 本文出自方志朋的博客 错过了这一篇，你可能再也学不会 Spring Cloud 了！Spring Boot做为下一代 web 框架，Spring Cloud 作为最新最火的微服务的翘楚，你还有什么理由拒绝。赶快上船吧，老船长带你飞。终章不是最后一篇，它是一个...
Spring Boot源码解读与原理分析
herosunly的博客
10-17 5万+
最近机缘巧合之下，读到了LinkedBear编写的《Spring Boot源码解读与原理分析》这本书，本人花了一周的时间认真研读了一下这本书，真的是受益匪浅，特此推荐给大家，好书不容错过啊。 文章目录 1. 关于作者 2. 本书定位 3. 目标读者 4. 读后感受 5. 书籍特点 6. 总结与展望 LinkedBear是一名资深的Java开发工程师，他倾力研究Spring技术体系多年，对Spring、Spring Boot、MyBatis等框架有独到的见解，拥有丰富的框架体系实践经验和架构封装经验。
Spring——Spring整合MyBatis
胜天半子祁同伟
03-13 2万+
Spring——Spring整合MyBatis
深入浅出 Spring Boot 3.x：从原理到实战，全面解锁 Java 后端开发新潮流
努力是为了站在万人之中，成为别人的光
04-25 4万+
Spring框架是Java EE开发的强有力的工具和事实标准，而Spring Boot采用“约定优于配置”的原则简化 Spring的开发，成为业界流行的微服务开发框架，被越来越多的企业采用。为了适应新潮流，本书对Spring Boot 3.x技术进行深入讲解。
springcloud整合nacos配置中心
Venus's Blog
06-07 7万+
如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，java基础面试题, netty, spring boot,spring cloud等系列文章，一系列干货随时送达!
Spring中文文档下载
09-27
Spring中文文档
spring jar包
08-05
spring-aop-3.2.2.RELEASE.jar spring-beans-3.2.2.RELEASE.jar spring-context-3.2.2.RELEASE.jar spring-context-support-3.2.2.RELEASE.jar spring-core-3.2.2.RELEASE.jar spring-data-commons-1.5.0.RELEASE....
spring源码
10-16
springmvc的源码，采用典型的三层架构进行开发，最简单的增删改查，登陆、修改密码等
SpringBlade开发手册基础版
05-23
SpringBlade开发手册基础版
【redis】Spring之RedisTemplate配置与使用
05-30 332
转载：Spring之RedisTemplate配置与使用用过redis，但直接使用Jedis进行相应的交互操作，现在正好来看一下RedisTemplate是怎么实现的，以及使用起来是否更加便利。
SpringBoot集成腾讯COS流程
最新发布
weixin_67727883的博客
05-30 267
SpringBoot集成腾讯COS流程
SpringBoot 的 Java 代码配置（二）
xiaotu的博客
05-29 1180
因此，如果使用 HikariCP 只用声明你要用它就行，而声明要使用 Druid，你需要自己指定所使用的版本。上面的 DruidDataSource ，我们为其属性赋值时，它的四个属性都是简单类型属性，因此十分容易处理。但是，在 Spring 的容器中，Java Bean 可能会存在引用。在上面的 Druid 的配置中，数据库连接的四大属性值是在代码中『写死』的。而在 Java 代码配置中，通过 @Bean 方法的入参来表达 Bean 之间的引用关系。，所以，我们可以直接将自定义的配置项写在。
SpringMVC 数据映射VC
weixin_45939821的博客
05-29 617
从 view 层发送请求到Controller，在Controller中获取参数： 在不输入值时会报400，参数错误 在不输入值时num默认为null 没有找到对应标签名称叫nums的，输入任何值时都报400 设置required默认值为false，即使表单没有nums也不会报错 设置defaultValues，参数num的默认值为1 可以直接给对象的属性赋值
spring saml
12-08
Spring Security SAML是Spring Security的一个扩展，它提供了对基于SAML 1.1，2.0和WS-Federation的单点登录（SSO）的支持。它允许您将SAML身份验证和授权集成到Spring Security中，以便您可以使用Spring Security的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值