【后端结合】新程序猿笔记Day4

最新推荐文章于 2024-09-09 09:47:53 发布
最新推荐文章于 2024-09-09 09:47:53 发布
阅读量152 收藏
点赞数
分类专栏： 后端总合 文章标签： 数据库 mysql database
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61729112/article/details/121660072
版权

1. 代理模式

1.1 创建项目

1.1.1创建项目

 1.1.2 完成入门代码测试

 1.1.3 编辑UserService

1.1.3.1 编辑Service接口

package com.jt.Service;

public interface UserService {
    void hello();
}

1.1.3.2 编辑ServiceImpl实现类

package com.jt.Service;

import org.springframework.stereotype.Service;

@Service
public class UserServicelmpl implements UserService {

    @Override
    public void hello() {
               System.out.println("新增用户");
    }
}

1.1.4 业务层如何控制事务

事务: 可以保证数据的/原子性/一致性/持久性/隔离性.
说明: 业务层操作时,需要考虑数据库的事务.代码结构如下:

package com.jt.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{

    @Override
    public void addUser() {
        try {
            System.out.println("开启数据库事务");
            System.out.println("新增用户");
            int a = 1/0;
            System.out.println("提交数据库事务");
        }catch (Exception e){
            System.out.println("事务回滚");
        }
    }
}

 1.1.4 业务代码-问题说明

  1. 如果有多个方法,则每个方法都需要控制事务. 代码重复率高.
  2. 业务层service,应该只处理业务,不要和事务代码耦合在一起.否则扩展性不好,耦合性高.

如何去解决：采用的代理机制解决

1.2 代理机制

1.2.1 代理模式特点

说明: 一般采用代理模式,主要的目的就是为了解耦.将公共的通用的方法(功能/业务)放到代理对象中. 由业务层专注于业务执行即可.

1.2.1 代理特点 

  1. 为什么使用代理? 因为自己不方便(没有资源)
  2. 代理的作用? 代理要解决(扩展)某些实际问题.
  3. 用户最终执行目标方法!!!

 

 1.3 动态代理-JDK模式

1.3.1 JDK代理的说明

  1. JDK代理模式是java原生提供的API,无需导包
  2. JDK代理要求: 被代理者必须 要么是接口,要么实现接口
  3. 灵活: 代理对象应该看起来和被代理者 一模一样!!! (方法相同)

1.3.2 编辑代理类

public class JDKProxy {
    //传入target目标的获取的代理对象
    //利用代理对象，实现方法的扩展
    public static Object getProxy(Object target){
        //1.获取类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
        //2.获取接口数组类型
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //代理对象执行方法的时的回调方法
        return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler(target));
    }
    //要求必须传递目标对象
    public static InvocationHandler invocationHandler(Object target){
        return new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("事物的开始");
                //获取目标方法的返回值
                Object invokes = method.invoke(target, args);
                System.out.println("事物的提交");
                    return invokes;
            }
        };
    }

 1.3.3 编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.proxy.JDKProxy;
import com.jt.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {

    @Test
    public void demo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //获取目标对象
        UserService userService = context.getBean(UserService.class);
        //userService.addUser();
        //获取代理对象
        UserService proxy = (UserService) JDKProxy.getProxy(userService);
        //代理对象执行方法, 调用invoke方法
        proxy.addUser();
    }
}

1.4 动态代理-JDK模式案例

需求: 要求大家计算addUser()方法的运行时间? 要求采用动态代理的方式完成.

1.4.1 编辑代理对象 

 public static Object getTimePorxy(Object target){
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class[] interfaces = target.getClass().getInterfaces();
        return Proxy.newProxyInstance(classLoader,interfaces,invocationHandlerTime(target));
    }

    //要求必须传递目标对象
    public static InvocationHandler invocationHandlerTime(Object target){
        return new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //开始时间
                long startTime = System.currentTimeMillis();
                //让目标方法执行 结果
                Object result = method.invoke(target,args);
                long endTime = System.currentTimeMillis();
                System.out.println("耗时:"+(endTime - startTime));
                return result;
            }
        };
    }

1.4.2 编辑测试方法

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.proxy.JDKProxy;
import com.jt.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {

    @Test
    public void demo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //获取目标对象
        UserService userService = context.getBean(UserService.class);
        System.out.println(userService.getClass());
        //userService.addUser();
        //获取代理对象
        UserService proxy = (UserService) JDKProxy.getTimePorxy(userService);
        System.out.println(proxy.getClass());
        //代理对象执行方法, 调用invoke方法
        proxy.addUser();
    }
}

1.5 动态代理-CGLIB代理

1.5.1 CGLIB说明

jdk代理: 要求必须有/实现接口. 如果没有接口,则JDK代理不能正常执行.
cglib代理: 要求被代理者有无接口都可以. 代理对象是目标对象的子类 重写子类方法

1.5.2 CGLIB代理模式 

package com.jt.proxy;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CGlibProxy {

    public static Object getProxy(Object target){
        //1.创建增强器对象
        Enhancer enhancer = new Enhancer();
        //2.设定父级 目标对象
        enhancer.setSuperclass(target.getClass());
        //3.定义回调方法 代理对象执行目标方法时调用
        enhancer.setCallback(getMethodInterceptor(target));
        //4.创建代理对象
        return enhancer.create();
    }
    //需要传递target目标对象
    public static MethodInterceptor getMethodInterceptor(Object target){
        return new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("事务开始");
                //执行目标方法
                Object result = method.invoke(target,args);
                System.out.println("事务提交");
                return result;
            }
        };
    }
}

1.6 关于JDK代理和CGlib代理总结(高程/架构)!!!

1. JDK要求必须有或者实现接口, cglib有无接口都可以创建代理对象.代理对象是目标对象的子类

2. JDK代理工具API: Proxy.newProxyInstance(类加载器,接口数组,invocationHandler接口)
3. CGlib代理工具API: Enhancer 增强器对象 获取代理对象 enhancer.create(); 回调接口
MethodInterceptor接口
4. JDK中执行目标方法
-method.invoke(target,args);
CGlib中执行目标方法
-method.invoke(target,args);

2. Spring AOP介绍 

2.1 创建项目

2.1.1 基本结构

创建AOP测试类

 2.1.2 层级代码结构

 2.1.3 层级代码结构

  <!--引入AOPjar包文件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

2.2 AOP

2.2.1 AOP介绍

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

总结: Spring中的AOP 利用代理对象在不修改源代码的条件下,对方法进行扩展. 

 2.2.2 AOP 入门案例

2.2.2.1 编辑配置类

@Configuration
@ComponentScan("com.jt") //包扫描
@EnableAspectJAutoProxy  //开启AOP
public class SpringConfig {
}

2.2.2.2 编辑切面类

package com.jt.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component  //将给类交给Spring容器管理  !!!
@Aspect     //标识该类是一个切面
public class SpringAOP {
    /**
     * 知识回顾: AOP利用动态代理扩展目标方法.
     * 公式:    切面 = 切入点表达式 + 通知方法
     * 切入点表达式: 如果目标对象满足切入点表达式的判断(if),则spring自动为其创建代理对象
     * 通知方法:  对目标方法进行扩展的封装方法.
     * 目标对象的bean的ID: userServiceImpl
     * 切入点表达式:
     *      1. bean("bean的ID")
     * AOP规则:  如果目标对象满足切入点表达式,则执行通知方法
     */
    @Pointcut("bean(userServiceImpl)")
    public void pointcut(){

    }

    //前置通知: 在目标方法执行之前执行.
    @Before("pointcut()")
    public void before(){
        System.out.println("我是前置通知!!!!");
    }
}

2.2.2.3 编辑测试类

package com.jt;

import com.jt.config.SpringConfig;
import com.jt.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestSpring {

    @Test
    public void demo1(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        //本来是目标对象,只不过与切入点表达式匹配,则动态生成代理对象.
        UserService userService = context.getBean(UserService.class);
        System.out.println(userService.getClass());
        //由于是代理对象,所以方法可以扩展
        userService.addUser();
    }
}

2.3 常见通知类型

package com.jt.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component  //将给类交给Spring容器管理  !!!
@Aspect     //标识该类是一个切面
public class SpringAOP {
    /**
     * 知识回顾: AOP利用动态代理扩展目标方法.
     * 公式:    切面 = 切入点表达式 + 通知方法
     * 切入点表达式: 如果目标对象满足切入点表达式的判断(if),则spring自动为其创建代理对象
     * 通知方法:  对目标方法进行扩展的封装方法.
     * 目标对象的bean的ID: userServiceImpl
     * 切入点表达式:
     *      1. bean("bean的ID")
     * AOP规则:  如果目标对象满足切入点表达式,则执行通知方法
     */
    @Pointcut("bean(userServiceImpl)")
    public void pointcut(){

    }

    //1.前置通知: 在目标方法执行之前执行.
    @Before("pointcut()")
    public void before(){
        System.out.println("我是前置通知!!!!");
    }

    //2.后置通知: 在目标方法执行之后执行
    @AfterReturning("pointcut()")
    public void afterReturn(){
        System.out.println("我是后置通知!!!!");
    }

    //3.异常通知: 目标方法执行报错时,执行该通知
    @AfterThrowing("pointcut()")
    public void afterThrowing(){
        System.out.println("我是异常通知!!!!");
    }

    //4.最终通知: 目标方法之后都要执行的通知
    @After("pointcut()")
    public void after(){
        System.out.println("最终通知都要执行");
    }

    //5.重点掌握 环绕通知: 在目标方法执行前后都要执行. 控制目标方法
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知执行前!!!!");
        //底层调用动态代理的invoke方法,执行目标方法
        Object result = joinPoint.proceed();
        System.out.println("环绕通知执行后!!!!");
        return result;
    }
}
程序猿 Simba
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员html基本笔记
weixin_57140106的博客
06-25 2291
黑马程序员html个人笔记
【C语言程序设计】笔记 day02
ZhangYuan_Cool的博客
02-08 626
C语言笔记-day02 P17_数组 1、数组的含义 一言以蔽之，数组就是存储一批同类型数据的地方。 2、定义数组 类型 数组名[常量表达式] int a[6]; // 定义一个整型数组，总共存放 6 个元素 一个int 4个字节 char b[24]; // 定义一个字符型数组，总共存放 24 个元素 一个char 4个字节 double c[3]; // 定义一个双精度浮点型数组，总共存放 3 个元素 一个double 8个字节 在定义数组时，需要在数组名后边紧跟着一对方括号，其中用常量表达式来指定数
Simba: Spatial In-Memory Big data Analytics
天下月色共三分的博客
02-17 574
simba
simba:辛巴
03-11
simba:辛巴
CGB2109-Day04
qq_16804847的博客
11-29 8155
1.Spring AOP知识讲解
探索SimBA：简单行为分析的利器
gitblog_00059的博客
06-08 350
探索SimBA：简单行为分析的利器 项目地址:https://gitcode.com/sgoldenlab/simba SimBA（Simple Behavioral Analysis）是一个强大的开源工具包，专为实验动物复杂社会行为的计算机分类而设计。借助机器学习的力量，SimBA简化了视频数据分析过程，让研究人员无需深厚的编程背景也能进行高效的行为分析。 项目介绍 SimBA的核心价值在于它提...
SimBas(简易VBscript编程环境)
12-17
这是我前几年用VB自编的一个程序,主要是一个应用的窗口介面,使用的是微软自家的Vbscript.DLL(或OCX), 使之开放出来用通常的Basic语言给人们使用. 就相当于小巧的原味的Basic语言,以解决一些小问题的求解. 因为是用Script语言,它没有直接的文件读写的语句.当然可以在其中写一些通过调用FSO的语句一样可以现实文件的读写功能. 压缩包里有一个示例程序,用来求解质数.
【C语言程序设计】笔记 day04
ZhangYuan_Cool的博客
02-11 494
C语言笔记-day04 P34_递归 1、递归的应用 汉诺塔 2、递归的实质 递归从原理上来说就是函数调用自身这么一个行为。 3、编写递归程序需要注意的地方 递归出口：递归程序需要正确设置结束条件，否则递归程序会一直走下去，直到崩溃。 递归点：将重复的事情交给程序做（自顶向下思考） 4、递归的优势和劣势 优势：递归的思考角度跟通常的迭代（你可以理解为 for 循环之类的）迥然不同，所以有时候使用迭代思维解决不了的问题，使用递归思维则一下子迎刃而解。 劣势：递归的执行效率通常比迭代低很多，所以递归程序要更消
苍穹外卖历时一个月终于写完啦！！！请白嫖我的笔记和完整代码吧！
02-21
【苍穹外卖】项目是一个基于JavaWeb技术的在线订餐系统，该项目的开发历经一个月的时间，作者分享了完整的源码和详细的笔记，旨在为学习者提供一个实践平台，加深对JavaWeb开发的理解。以下是该项目涉及的主要知识点...
2021-03-08~09~10~11~12 大数据课程笔记 day47day48day49day50day51
qq_44745905的博客
03-12 1103
@R星校长 大数据技术之Flink 第一章 初识Flink   在当前数据量激增的时代，各种业务场景都有大量的业务数据产生，对于这些不断产生的数据应该如何进行有效的处理，成为当下大多数公司所面临的问题。目前比较流行的大数据处理引擎Apache Spark，基本上已经取代了MapReduce成为当前大数据处理的标准。但对实时数据处理来说，Apache Spark的Spark-Streaming还有性能改进的空间。对于Spark-Streaming的流计算本质上还是批（微批）计算，Apache Flink.
simba:一组数学特征，以方便使用基于SIMD的AoSoA（数组结构数组）存储模式
05-08
Simba-用于Rust的SIMD代数 | 用于Rust编程语言的SIMD代数。 金牌赞助商 Simba受以下支持：
MES对接Simba实现展讯平台 IMEI 写号与耦合测试
m0_56069948的博客
08-09 1462
文章开始之前，必须对Simba工具点一个大大的赞，Simba为了适应市面上不同厂家开发的 MES 系统，特地开发了统一的接口，各个 MES 厂家只需要按照接口规范去做开发，然后将中间件加载到 Simba，就能实现数据对接了，非常方便，扩展性非常好！设备连接到电脑之后，启动Simba工具，负责数据交互的中间件与MES进行交互，请求服务器分配 IMEI、MAC等信息，本地获取到IMEI信息之后进行写号，写号成功之后调用 MES 接口进行报工。...
分布式空间分析引擎-Simba架构分析与源码阅读之总体架构
u013970710的博客
11-23 855
Simba（SpatialIn-MemoryBig dataAnalytics）是一个基于Spark开发的分布式空间分析引擎，主打空间大数据的高spatial join性能 。它基于Spark SQL框架进行扩展，针对空间场景进行了一系列的算法研究和工程优化，在spatial join领域相对geospark、SpatialHadoop、Hadoop GIS等空间分析引擎具有一定的优势。下面...
Ubuntu下使用Simba服务实现局域网内文件共享
xiao229404041的专栏
10-14 1122
Ubuntu下安装Simba服务器将linux电脑上的内容共享，同一局域网内的另外一台Windows PC即可访问其共享内容， 从而实现Windows电脑向访问本地文件一样访问Linux文件系统的内容。 (1)安装Simaba服务器 sudo apt-get insta
函数式编程扫盲篇
weixin_34348174的博客
03-07 544
1. 概论 在过去的近十年的时间里，面向对象编程大行其道。以至于在大学的教育里，老师也只会教给我们两种编程模型，面向过程和面向对象。 孰不知，在面向对象产生之前，在面向对象思想产生之前，函数式编程已经有了数十年的历史。 那么，接下来，就让我们回顾这个古老又现代的编程模型，让我们看看究竟是什么魔力将这个概念，将这个古老的概念，在21世纪的今天再次拉入了我们的视野。 2. 什么是函数式编程...
spring事务详细讲解-深入浅出
小电玩
09-08 457
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
【提效工具】AI工作流的1-10个实际落地场景
最新发布
万物皆有灵
09-09 775
在这个快速发展的数字时代，人工智能（AI）正在以惊人的速度改变我们的工作方式。无论你是开发者、教育工作者还是内容创作者，AI工作流提示词助手都能为你提供无与伦比的支持。今天，我们将深入探讨，20个实际落地场景，帮助你更好地理解如何利用这些工具提升工作效率和创造力。💡。
【MYSQL】
ABC1234567890ABM的博客
09-06 948
单列索引情况：根据下图可以看到，查询条件中有phone和name，他们都有单列索引，但是执行explain后发现真正只走了phone的索引，因为phone索引中没有name值，故还需回表走一次聚簇索引。为了避免DML在执行时，加的行锁与表锁的冲突，在InnoDB中引入了意向锁，使得表锁不用检查每行数据是否加锁，使用意向锁来减少表锁的检查。全局锁就是对整个数据库实例加锁，加锁后整个实例就处于只读状态，后续的DML的写语句，DDL语句，已经更新操作的事务提交语句都将被阻塞。表级锁，每次操作锁住整张表。
jmeter之setUP、tearDown线程组
回家吃月饼的学习交流地
09-07 508
jmeter之setUP、tearDown线程组的使用
C++数据结构详解与程序员实战笔记
本资源是一份资深程序员关于C++数据结构的笔记，专为初学者设计，旨在帮助他们掌握基础的C++数据结构编程技巧和注意事项。内容覆盖了软考指南中涉及的核心知识点，包括： 1. 数据结构基础知识：对象定义、存储表示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值