SSM框架之Spring学习笔记2

最新推荐文章于 2024-07-24 13:08:50 发布

你不必是我的

最新推荐文章于 2024-07-24 13:08:50 发布

阅读量217

点赞数

文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_46003863/article/details/122470742

版权

Spring 装配与 AOP

Bean的自动装配

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

Spring 的装配方式

在 xml 中显示的配置

及手动配置

<bean id="user" class="com.yqly.pojo.User" p:name="小王" p:age="17"/>

在 Java 中显示配置

隐式的自动装配 bean

autowire：通过该字段定义自动装配方式

ByName 自动装配

自动在容器上下文中查找和自己对象 set 方法对应的参数的值对应的 beanid

<bean id="people" class="com.yqly.pojo.People" autowire="byName">

在这里插入图片描述

ByType 自动装配

自动在容器上下文中查找和自己对象 set 方法对应的参数类型相同的 bean 类型
ByType 自动装配必须保证 bean 类型全局唯一
ByType 根据 bean 类型自动装配，所以可以省略 id

<bean id="people" class="com.yqly.pojo.People" autowire="byType">

在这里插入图片描述

使用注解实现自动装配

使用注解实现自动装配的前提：

导入约束

xmlns:context="http://www.springframework.org/schema/context"

配置注解支持

http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd

开启注解自动装配

<context:annotation-config/>

@Autowired

可以直接在属性上使用，也可以在 set 方法上使用
当该注解在属性上使用时，可以不用编写 set 方法，前提是这个自动封装的属性在 IOC（Spring）容器中
优先按类型自动装配，当同一类型下有多个 bean 时，可以配合 @Qualifier 注解一起使用来指定 beanid 来实现自动装配

<bean id="cat" class="com.yqly.pojo.Cat"/>
<bean id="cat1" class="com.yqly.pojo.Cat"/>

@Autowired
@Qualifier("cat1")       //对指定beanid进行自动装配
private Cat cat;

@Resource

使用范围与 @Autowired 一样
是 Java 自带的注解，不需要导包
优先通过 beanid 自动装配，名字不匹配再通过类型装配，当一个类型下有多个 bean 时，可以通过指定 beanid 来实现自动装配

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

使用注解开发

在 Spring4 之后要使用注解开发必须保证 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: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:component-scan base-package="com.yqly.pojo"/>
</beans>

注解导入 bean

@Component
等价于

<bean id="user" class="com.yqly.pojo.User"/>

@Component
public class User {
    public String name;
}

@Component 同类型的注解

这类注解的功能都是代表将某个类注册到 Spring 中，装配 Bean

注解名称	适用环境
@Component	pojo 层
@Repository	dao 层
@Service	service 层
@Controller	controller 层

属性注入

@Value

可以放在属性上，也可以放在 set 方法上
等价于

<property name="name" value="小王"/>

public class User {
    @Value("小王")
    private String name;

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

使用 Java 的方式配置 Spring

完全不使用 xml 配置文件，而是通过配置类实现
如果完全使用了配置类方法，我们只能够通过 AnnotationConfigApplicationContext 来获取容器，通过配置文件的 class 对象加载

pojo 类

//等价于<bean id="user" class="com.yqly.pojo.User"/>
public class User {
    @Value("小王")   
    private String name;

    public String getName() {
        return name;
    }

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

配置类

@Configuration

代表这是一个配置类，类似于之前的xml配置文件
@Bean

注册一个 bean，就相当于我们之写的 bean 标签，方法名相当于 id，返回值相当于 class

<bean id="user" class="com.yqly.pojo.User"/>

@Configuration 
public class YConfig {
    @Bean       
    public User user(){
        return new User();
    }
}

测试

通过 getBean 方法取的名字要与配置类中的方法名一致

ApplicationContext context = new AnnotationConfigApplicationContext(YConfig.class);
User user = context.getBean("user",User.class);
System.out.println(user.getName());

@import

将其他配置类引入到该配置类中，类似于 xml 中的 import 标签

代理模式

SpringAOP 的底层
代理模式：

静态代理模式

动态代理模式

静态代理

角色分析

抽象角色：一般会使用接口或者抽象类来解决

//租房，抽象角色
public interface Rent {
    public void rent();
}

真实角色：被代理的角色

//房东，真实角色
public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("出租房子！");
    }
}

代理角色：代理真实角色（代理真实角色后一般会做一些附属操作）

//中介，代理角色
public class Proxy implements Rent{

    private Host host;

    public Proxy() {
    }

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

    @Override
    public void rent() {
        LookHouse();
        host.rent();
        IntermediaryFees();
        SignContract();
    }
    public void LookHouse(){
        System.out.println("看房子");
    }
    public void IntermediaryFees(){
        System.out.println("收中介费");
    }
    public void SignContract(){
        System.out.println("签合同");
    }
}

客户：访问代理对象的人

//客户
public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

代理模式优点

可以使真实角色的操作更加纯粹，不用去关注一些公共的业务
公共业务交给代理角色，实现了业务的分工
公共业务发生拓展时，方便集中管理
代理角色不会对真实角色进行修改，只会对其进行功能扩展

代理模式缺点

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

动态代理

角色与静态代理一样
动态代理的代理角色（代理类）是动态生成的，不是直接写好的
动态代理分为两大类：

基于接口的动态代理 —— JDK 动态代理

基于类的动态代理 —— GBLIB

也可以通过 Java 字节码实现 —— Javasist
需要了解两个类：Proxy（代理），InvocationHandler（调用处理程序）

InvocationHandler

是由代理实例的调用处理程序实现的接口
每个代理实例都有一个关联的调用处理程序
可以通过该类自动生成代理类，会根据传入的真实角色类型自动生成相应类型的代理类

public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }
    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    //处理代理类，并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质就是使用反射机制实现
        log(method.getName());
        Object invoke = method.invoke(target, args);
        return invoke;
    }
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

public class Client {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        proxyInvocationHandler.setTarget(userService);
        UserService proxy = (UserService) proxyInvocationHandler.getProxy();
        proxy.add();
    }
}

动态代理优点

包含静态代理的所有优点
一个动态代理类代理的是一个接口，一般就是对应的一类业务
一个动态代理类可以实现多个类，只要是实现了同一个接口即可

AOP

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

在这里插入图片描述

AOP 在 Spring 中的作用

提供声明式事务，允许用户自定义切面
横切关注点：跨越应用程序多个模块的方法或者功能，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
切面（ASPECT）：横切关注点被模块化的特殊对象，切入点 + 通知，是一个类
通知（Advice）：切面必须要完成的工作，增强代码，是类中的一个方法
切入点（PointCut）：切面通知，切面执行的 ”地点“ 的定义
目标（Target）：被代理的对象
代理（Proxy）：向目标对象应用通知后创建的对象，用来实现切面
连接点（JointPoint）：与切入点匹配的执行点
引入（Introduction）：声明某个方法或字段
织入（Weaving）：将通知应用到切入点的过程

在这里插入图片描述

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

通知类型	连接点	实现接口
前置通知	方法前	org.springframework.aop.MethodBeforeAdvice
后置通知	方法后	org.springframework.aop.AfterReturningAdvice
环绕通知	方法前后	org.springframework.aop.MethodInterceptor
异常抛出通知	方法抛出异常	org.springframework.aop.ThrowsAdvice
引介通知	类中增加新的方法属性	org.springframework.aop.IntroductionInterceptor

使用 Spring 实现 AOP

导入依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
    <scope>compile</scope>
</dependency>

导入约束

<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">

开启支持
可以通过修改 proxy-target-class 参数改变动态代理类型，默认为 false（JDK），true（GBLIB）

<aop:aspectj-autoproxy proxy-target-class="false"/>

需要代理的接口及实现类

需要代理的接口

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

接口实现类

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("查询一个用户");
    }
}

第一种实现方式

使用原生的 Spring 的 API 接口
- 切入点：pointcut
- 表达式：expression：execution (* com.demo01.service.UserServiceImpl…*. *(…)）
  - execution()：表达式主体
  - 第一个 * 号：表示返回类型， * 号表示所有的类型
  - 包名：表示需要拦截的包名，后面的两个句点表示当前包和当前包的所有子包，com.demo01.service.UserServiceImpl 包、子孙包下所有类的方法
  - 第二个 * 号：表示类名，* 号表示所有的类
  - 最后一个 * 号：表示方法名，* 号表示所有的方法，后面括弧里面表示方法的参数，两个句点表示任何参数

横切关注点

method：要执行的目标对象的方法
args：参数
target：目标对象
returnValue：返回值

public class Log implements MethodBeforeAdvice {
    @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 {
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为"+returnValue);
    }
}

<bean id="userService" class="com.demo01.service.UserServiceImpl"/>
<bean id="beforeLog" class="com.demo01.log.Log"/>
<bean id="afterLog" class="com.demo01.log.AfterLog"/>

<!--配置AOP，需要导入AOP的约束--> 
<aop:config>
    <!--切入点:pointcut
    表达式:expression:
    execution:要执行的位置(修饰词 返回值 类名 方法名 参数-->
    <aop:pointcut id="pointcut" expression="execution(* com.demo01.service.UserServiceImpl.*(..))"/>
    <!--通知-->
    <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>

第二种实现方式

自定义实现 AOP

自定义类

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

<bean id="userService" class="com.demo01.service.UserServiceImpl"/>
<bean id="diy" class="com.demo01.diy.DiyPointCut"/>

<aop:config>
    <!--自定义切面
        ref:要引用的类-->
    <aop:aspect ref="diy">
        <!--切入点-->
        <aop:pointcut id="point" expression="execution(* com.demo01.service.UserServiceImpl.*(..))"/>
        <!--通知-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

第三种实现方式

注解实现 AOP

自定义类

在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点，可以通过参数获取相关信息

@Aspect       //标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* com.demo01.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("方法正在执行");
    }
    @After("execution(* com.demo01.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("方法执行完毕");
    }
    @Around("execution(* com.demo01.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        Signature signature = jp.getSignature();        //获得签名
        System.out.println(signature);
        Object proceed = jp.proceed();       //执行方法
        System.out.println("环绕后");
    }
}

<bean id="annotationPointCut" class="com.demo01.diy.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>

在这里插入图片描述

你不必是我的

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SSM框架之Spring学习笔记2

SpringBean的自动装配自动装配是 Spring 满足 bean 依赖的一种方式Spring 会在上下文自动寻找，并自动给 bean 装配属性Spring 的装配方式在 xml 中显示的配置及手动配置<bean id="user" class="com.yqly.pojo.User" p:name="小王" p:age="17"/>在 Java 中显示配置隐式的自动装配 beanautowire：通过该字段定义自动装配方式ByName 自动装配自
复制链接

扫一扫