Spring Boot 实战基础 AOP

最新推荐文章于 2022-01-05 14:47:59 发布
最新推荐文章于 2022-01-05 14:47:59 发布
阅读量118 收藏
点赞数
分类专栏： Spring Boot 学习 
				版权声明：本文为博主原创文章，未经博主允许不得转载。					https://blog.csdn.net/u010819416/article/details/53395585				</div>
							<link rel="stylesheet" href="https://csdnimg.cn/release/phoenix/template/css/ck_htmledit_views-f57960eb32.css">
							            <div id="content_views" class="markdown_views">
						<!-- flowchart 箭头图标 勿删 -->
						<svg xmlns="http://www.w3.org/2000/svg" style="display: none;"><path stroke-linecap="round" d="M5,0 0,2.5 5,5z" id="raphael-marker-block" style="-webkit-tap-highlight-color: rgba(0, 0, 0, 0);"></path></svg>
						<p>第1章 Spring基础</p>

1.1 Spring概述

1.1.1 Spring的简史
第一阶段：xml配置
第二阶段：注解配置
基本配置(如数据库配置)用xml，业务配置用注解。
第三阶段：Java配置
Java配置可以更理解配置的Bean。推荐使用Java配置。

1.1.2 Spring概述
企业级开发的一站式解决方案。所谓解决方案就是可以基于Spring解决Java EE开发的所有问题。

1.Spring的模块

2.Spring的生态
Spring Boot：使用默认开发配置来实现快速开发。
Spring Data：对主流的关系型和NoSQL数据库的支持
Spring Security：通过认证和授权保护应用
Spring Session：提供一个API及实现来管理用户会话信息
。。。

1.2 Spring项目快速搭建

1.3 Spring基础配置
Spring框架本身有四大原则：
1）使用POJO进行轻量级和最小侵入式开发
2）通过依赖注入和默认习惯进行声明式编程。
3）使用AOP和默认习惯进行声明式编程
4）使用AOP和模板（template）减少模式化代码

1.3.1 依赖注入
1.点睛
控制翻转（IOC）和依赖注入（DI）在Spring环境下是等同的概念，控制翻转是通过依赖注入实现的。所谓依赖注入指的是容器负责创建对象和维护对象间的依赖关系。
声明Bean的注解：
@Component
@Repository
@Service
@Controller
注入Bean的注解：
@Autowired：Spring提供的注解
@Inject：JSR-330提供的注解
@Resource：JSR-250提供的注解

2.示例
演示基于注解的Bean的初始化和依赖注入

package com.wisely.highlight_spring4.ch1.di;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

//@Service 
@Repository
//@Controller
//@Component
//使用Repository,Service,Controller,Component是等效的
public class FunctionService {
    public String sayHello(String word){
        return "Hello " + word +" !"; 
    }

}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
package com.wisely.highlight_spring4.ch1.di;

import javax.annotation.Resource;
import javax.inject.Inject;

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

@Service //1
public class UseFunctionService {
    //@Autowired 
    //@Inject
    @Resource
    //Autowired,Inject,Resource是等效的,使用Inject需要额外加入javax.inject依赖。
    FunctionService functionService;

    public String SayHello(String word){
        return functionService.sayHello(word);
    }

}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
package com.wisely.highlight_spring4.ch1.di;

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

@Configuration //声明当前类是一个配置类
@ComponentScan("com.wisely.highlight_spring4.ch1.di") 
//自动扫描包下所有使用@Servcie,@Component,@Repository,@Controller的类，
//并注册为Bean
public class DiConfig {

}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
package com.wisely.highlight_spring4.ch1.di;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
         AnnotationConfigApplicationContext context =
                    new AnnotationConfigApplicationContext(DiConfig.class); 
         //使用AnnotationComfigApplicationContext作为Spring容器，接受输入一个配置类作为参数

         UseFunctionService useFunctionService = context.getBean(UseFunctionService.class); //2

         System.out.println(useFunctionService.SayHello("world"));

         context.close();
    }
}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

1.3.2 Java配置
1.点睛
Java配置是通过@Configuration和@Bean来实现的。
*@Configuration声明类是一个配置类，相当于一个Spring配置的xml文件。
*@Bean注解在方法上，声明当前方法的返回值为一个Bean。

*全局配置使用Java配置（如数据库相关配置、MVC相关配置），业务Bean的配置使用注解配置。

2.示例
演示简单的Java配置。

package com.wisely.highlight_spring4.ch1.javaconfig;
//1
public class FunctionService {
    public String sayHello(String word){
        return "Hello " + word +" !"; 
    }
}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
package com.wisely.highlight_spring4.ch1.javaconfig;

import com.wisely.highlight_spring4.ch1.javaconfig.FunctionService;
//1
public class UseFunctionService {
    //2
    FunctionService functionService;

    public void setFunctionService(FunctionService functionService) {
        this.functionService = functionService;
    }

    public String SayHello(String word){
        return functionService.sayHello(word);
    }

}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
package com.wisely.highlight_spring4.ch1.javaconfig;

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

@Configuration //1
public class JavaConfig {
    @Bean //2
    public FunctionService functionService(){
        return new FunctionService();
    }

    @Bean 
    public UseFunctionService useFunctionService(){
        UseFunctionService useFunctionService = new UseFunctionService();
        useFunctionService.setFunctionService(functionService()); //3
        return useFunctionService;

    }

//  @Bean 
//  public UseFunctionService useFunctionService(FunctionService functionService){//4
//      UseFunctionService useFunctionService = new UseFunctionService();
//      useFunctionService.setFunctionService(functionService);
//      return useFunctionService;
//  }
}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
package com.wisely.highlight_spring4.ch1.javaconfig;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
         AnnotationConfigApplicationContext context =
                    new AnnotationConfigApplicationContext(JavaConfig.class); 

         UseFunctionService useFunctionService = context.getBean(UseFunctionService.class); 

         System.out.println(useFunctionService.SayHello("java config"));

         context.close();

    }
}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

1.3.3 AOP
1.点睛
AOP面向切面编程。
Spring支持AspectJ的注解式切面编程。
（1） 使用@Aspect申明是一个切面
（2）使用@After、@Before、@Around定义建言（advice）,可直接将拦截规则（切点）作为参数。
（3）其中@After、@Before、@Around参数的拦截规则为切点（PointCut），为了使切点复用，可使用@PointCut专门定义拦截规则，然后在@After、@Before、@Around的参数中调用。
（4） 其中符合条件的每一个被拦截处为连接点（JoinPoint）

package com.wisely.highlight_spring4.ch1.aop;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Action {
    String name();
}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
package com.wisely.highlight_spring4.ch1.aop;

import org.springframework.stereotype.Service;

@Service
public class DemoAnnotationService {
    @Action(name="注解式拦截的add操作")
    public void add(){} 

}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
package com.wisely.highlight_spring4.ch1.aop;

import org.springframework.stereotype.Service;

@Service
public class DemoMethodService {
    public void add(){}
}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
package com.wisely.highlight_spring4.ch1.aop;

import java.lang.reflect.Method;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;


@Aspect //1
@Component //2
public class LogAspect {

    @Pointcut("@annotation(com.wisely.highlight_spring4.ch1.aop.Action)") //3
    public void annotationPointCut(){};

      @After("annotationPointCut()") //4
        public void after(JoinPoint joinPoint) {
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            Action action = method.getAnnotation(Action.class); 
            System.out.println("注解式拦截 " + action.name()); //5
        }

       @Before("execution(* com.wisely.highlight_spring4.ch1.aop.DemoMethodService.*(..))") //6
        public void before(JoinPoint joinPoint){
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            System.out.println("方法规则式拦截,"+method.getName());

        }



}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
package com.wisely.highlight_spring4.ch1.aop;

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

@Configuration
@ComponentScan("com.wisely.highlight_spring4.ch1.aop")
@EnableAspectJAutoProxy //1
public class AopConfig {

}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
package com.wisely.highlight_spring4.ch1.aop;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
         AnnotationConfigApplicationContext context =
                    new AnnotationConfigApplicationContext(AopConfig.class); //1

         DemoAnnotationService demoAnnotationService = context.getBean(DemoAnnotationService.class);

         DemoMethodService demoMethodService = context.getBean(DemoMethodService.class);

         demoAnnotationService.add();

         demoMethodService.add();

         context.close();
    }

}

 
 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

这里写图片描述

github代码

天空中的小虾米
关注
专栏目录
《滚雪球学Spring Boot》教程导航帖（更新于2024.06.20）
**My Coding Family**
06-29 4万+
《滚雪球学Spring Boot》是由CSDN博主bug菌创作的全面Spring Boot教程。作者是全栈开发专家，在多个技术社区如CSDN、掘金、InfoQ、51CTO等担任博客专家，并拥有超过30万的全网粉丝。该教程分为入门篇和进阶篇，每篇包含详细的教学步骤，涵盖Spring Boot的基础和高级主题。
springboot实战原理分析笔记（十三）- springboot aop
fsdf8sad7的博客
07-16 238
1.spring-boot-starter-aop加入依赖，默认就开启Aop的支持 2.写一个Aspect,封装横切关注点（日志、监控等等） ，需要配置通知（前置通知， 后置通知等等）和切入点（那些包的类得那些方法） 3.这个Aspect要纳入spring容器中管理 配置文件可以配置 是否启用Aop : spring.aop.auto=true spring.aop.auto设置是否启动，默认...
彻底征服 Spring AOP 之 实战篇
B-Tree
09-06 1183
转：http://www.cnblogs.com/jasonHome/p/6063830.html Spring AOP 实战 看了上面这么多的理论知识, 不知道大家有没有觉得枯燥哈. 不过不要急, 俗话说理论是实践的基础, 对 Spring AOP 有了基本的理论认识后, 我们来看一下下面几个具体的例子吧.下面的几个例子是我在工作中所遇见的比较常用的 Spring AOP 的使用场景, 我精简
SpringBoot-AOP面向切面编程-实战
ZhAoYaJ的博客
01-05 2293
SpringBoot集成AOP之列文虎克
理解Spring AOP
xjyr的专栏
07-07 352
直接看例子吧，示例来自 汪云飞的 《Spring boot 实战》， 重点是看 LogAspect.java 上面有我的注释.直接看例子吧com.wisely.highlight_spring4.ch1.aop.Main 1st.      @interface  @Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Docu...
NoSuchBeanDefinitionException：No qualifying bean of type 解决方法
杜仁栋的专栏
01-15 7万+
最近在给团队里面的新成员做培训，发现有些问题新成员特别容易犯，其中一条就是通过spring的AnnotationConfigApplicationContext去获取依赖注入的实例对象的时候， 经常会报类似这种的异常：Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException:
Spring Boot 实战教程，由浅入深详细介绍springboot的使用
最新发布
03-12
### Spring Boot 实战教程知识点详解 #### 一、Spring Boot 简介 **1.1 Spring 概述** Spring 是一个开源框架，最初由 Rod Johnson 创建，它为 Java 应用程序提供了一种简化的方式来处理依赖管理和面向切面编程...
Spring Boot 2.5.0简单学习pdf资料
09-18
在 pom.xml 文件中，我们可以添加依赖项，例如 junit、spring-core、spring-beans、spring-aop 等。 Spring MVC Spring MVC 是 Spring Framework 中的一个模块，提供了基于模型视图控制器（MVC）的Web应用程序开发...
Spring Boot缓存实战 Caffeine示例
08-27
Spring Boot 缓存实战 Caffeine 示例 概述：本文介绍了使用 Spring Boot 实现缓存实战的示例，使用 Caffeine 作为缓存框架。Caffeine 是一个使用 Java 8 重写的 Guava 缓存版本，在 Spring Boot 2.0 中将取代 Guava...
java execution_aspectj 注解中 execution()的问题
weixin_39637256的博客
02-24 415
错误如下包结构如下这是我的方法@Before("execution(*com.wisely.highlight_spring4.ch1.aop.DemoMethodService.*(..))")public void before(JoinPoint joinPoint){MethodSignature signature=(MethodSignature)joinPoint.getSignat...
遇到的各种java问题
qq_40604853的博客
11-16 440
1.Project configuration is not up-to-date with pom.xml. Select: Maven->Update Project... from the project context menu or use Quick Fix. highlight_spring4 line 1 Maven Configuration Pr...
spring 四大原则
u012352395的专栏
03-13 775
1.使用pojo进行轻量级和最小倾入式开发。 2.通过依赖注入和基于接口编程实现松耦合。 3.通过aop和默认习惯进行声明式编程。 4.使用aop和模板减少模式化代码。
No qualifying bean of type [com.exe.demo01.ch1.di.UseFunctionService] is defined
hdn_kb的博客
09-28 688
1.编写功能类的Bean 2.使用功能类的Bean 3.配置类 4.运行 以上为正确的代码！ 出现No qualifying bean of type [com.exe.demo01.ch1.di.UseFunctionService] is defined错误的原因如下： 1.在配置类中忘记扫描包，或扫描的包路径写错 2.在运行的main方法中，.使用Annot...
SpringBoot学习——运行原理学习及自定义Starter pom
flygoa的专栏
03-30 1万+
SpringBoot学习——运行原理学习及自定义Starter pom项目下载项目下载运行原理SpringBoot最大的特点就是提供了很多默认的配置，Spring4.x提供了基于条件来配置Bean的能力，SpringBoot就是通过这一原理来实现的。 那么我们如何来实现一个自定义的starter呢自定义Starter pom新建一个maven项目参考SpringBoot学习——SpringBoot
Springboot AOP 实战
10年IT大头兵
05-10 529
简介 此处，只梳理AOP的基本概念和应用。底层原理是动态代理和反射，不作探究。 aop 面向切面 ：大白话来说就是针对一些类的一些方法需要追加一些功能，这些功能和原来的逻辑无关。 切面编程的三个要素： 这些功能可以单独定义一个类来实现称之为通知。 另外再通过一个类实现追加，这个类称之为切面。 那么这些待追加功能的方法就是称为切入点。 1实战 1.1 依赖 spring boot项目中使用AOP 需要添加maven依赖 <dependency> ...
Disconf web管理端安装
weixin_34265814的博客
02-21 211
1.环境配置配置java、maven环境，并安装mysql，reids，zookeeeper，Nginx2.下载disconf下载https://codeload.github.com/knightliao/disconf/zip/master解压：unzip disconf-master.zip3.编译打包创建目录 [plain] view plain copy    prin...
no qualifying bean of type bean的解决方法
热门推荐
weixin_43843824的博客
07-02 7万+
java程序编写时，当bean文件中有多个类而使用@Autowired时未进行指定就会出现这个错误，解决方法如下： 未解决前： manager处是报错的。 解决方法： 使用 @Qualifier和**@Service** 在实现的类处使用@Service标记： 使用该类的地方使用@Qualifier标记： 标记名即括号内内容可以任意但是两处需要相同。 ...
Disconf,百度的分布式配置管理平台
日拱一卒
11-23 9725
disconf 可以为各种业务平台提供统一的配置管理服务。 支持配置（配置项+配置文件）的分布式化管理 配置发布统一化 极简的使用方式（注解式编程 或 XML代码无代码侵入模式） 低侵入性或无侵入性、强兼容性 需要Spring编程环境 重要功能特点 支持配置（配置项+配置文件）的分布式化管理 配置发布
Spring理解
木子李的博客
05-05 150
Spring基础 spring可以实现很多功能，但是在日常项目开发过程中最常用到的还是依赖注入DI和面向切面编程AOP，其实spring最根本的目的就是简化代码开发。 如果你在spring之前接触过java开发，你会发现很多框架会强迫应用继承他们的类或实现他们的接口从而让应用和框架进行绑死，而Spring不会强迫你实现Spring的一些接口或者集成Spring规范的类，通常我们在使用Spring的...
Spring Boot AOP 实战：统一Web请求日志处理
"本文将深入探讨如何在Spring Boot应用中利用AOP（面向切面编程）来统一处理Web请求日志。通过AOP，我们可以创建一个全局的拦截器，无侵入地对所有Web请求进行日志记录，提高代码的可维护性和整洁性。" 在Spring ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值