Spring

已于 2024-06-26 15:38:05 修改
阅读量351 收藏 4
点赞数 5
文章标签： spring mvc java
于 2024-06-22 16:26:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaozhao_1/article/details/139871683
版权

一、 MVC三层架构

在这里插入图片描述

Model

  • 业务处理：业务逻辑（Service）
  • 数据持久层：CRUD（Dao）

View

  • 展示数据
  • 提供链接发起Service请求（a、form、img…）

Controller

  • 接收用户的请求（req：请求参数、Session信息）
  • 交给业务层处理对应的代码
  • 控制视图的跳转

登陆---->接受用户登陆请求---->处理用户请求（获取用户登陆参数：username、password）---->交给业务层处理登陆业务（判断用户名是否正确）---->Dao层查询用户名和密码是否正确---->数据库

过滤器（Filter）

在这里插入图片描述
步骤：

  1. maven导包
  2. 实现javax.servlet的Filter接口，重新特定方法
  3. 配置web.xml

注意：
1.过滤中的所有代吗，在过滤特定请求的时候都会执行
2、必须要让过滤器继续通行
chain.doFilter(request,response);

案例：设置两条路径，/filter/hello_filter以及/hello_filter，通过过滤器实现/filter/*的路径设置编码格式。最终显示：/filter/hello_filter正常输出中文格式的“你好世界！”，/hello_filter输出乱码

//展示类
public class FilterServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().println("<h1>世界，你好！</h1>");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

Filter类，注意导包Filter为javax.servlet包下的Filter

public class FilterTest implements Filter {
	//初始化在系统启动时就加载
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("Filter init");
    }

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    	//设置编码格式操作
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        servletResponse.setContentType("text/html;charset=utf-8");

        System.out.println("Filter doFilter Before");
        //正确执行过滤器，必须加此行，不然会一直卡死不往下执行
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("Filter doFilter After");
    }
	//销毁在系统关闭时销毁
    public void destroy() {
        System.out.println("Filter destroy");
    }
}

web.xml，配置servlet和filter：
/filter/hello_filter和/hello_filter都可以进入展示类
filter配置地址前缀为/filter的才可进入

    <servlet>
        <servlet-name>FilterIndex</servlet-name>
        <servlet-class>com.zzz.filter.FilterServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>FilterIndex</servlet-name>
        <url-pattern>/filter/hello_filter</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>FilterIndex</servlet-name>
        <url-pattern>/hello_filter</url-pattern>
    </servlet-mapping>

    <filter>
        <filter-name>FilterTest</filter-name>
        <filter-class>com.zzz.filter.FilterTest</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>FilterTest</filter-name>
        <url-pattern>/filter/*</url-pattern>
    </filter-mapping>

JDBC复习

常用接口

(1) Driver 接口:加载驱动程序。
(2) DriverManager 类:装人所需的 JDBC 驱动程序，编程时调用它的方法来创建连接。
(3) Connection 接口:编程时使用该类对象创建 Statement 对象。
(4) Statement 接口:编程时使用该类对象得到 ResultSet 对象。
(5) ResultSet 类:负责保存 Statement 执行后所产生的查询结果。

连接数据库

  1. 提前创建好数据库
CREATE DATABASE db1;
 
USE db1;
 
CREATE TABLE `user`(
	`id` INT,
	`name` VARCHAR(30)
);
 
INSERT INTO `user` VALUES (1,'张一'),(2,'张二'),(3,'张三'),(4,'张四'),(5,'张五');
  1. 导包

  1. 连接Mysql
//注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
Connection com = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", "root", "123456");
Statement stat = com.createStatement();

// 执行 增删改查 （DML）语句用 int executeUpdate(Sting sql);
 // 执行 DQL 语句 ResultSet executeQuery(String sql);
String sql = "SELECT * FROM user";
ResultSet rs = stat.executeQuery(sql);

while (rs.next()){
        System.out.println(rs.getInt("id") + "\t" + rs.getString("name"));
}
 stat.close();
 com.close();

JDBC 预编译

JDBC事务

  1. 开启事务 void setAutoCommit(boolean autoCommit)
  2. 提交事务 void commit() 使自上次提交/回滚以来所做的所有更改为永久更改，并释放此Connection对象当前持有的所有数据库锁。
  3. 回滚事务 void rollback() 撤销当前事务中所做的更改，并释放此Connection对象当前持有的所有数据库锁
try{
connection.setAutoCommit(false);//设置为false，开启事务
...sql语句

connection.commit();//以上两条SQL都执行成功就提交事务。
}catch(){
connection.rollback();
}

二、Spring

1、优点

  • Spring是一个轻量级的框架 , 非侵入式的 （不会破坏原有程序，甚至简化原有代码）
  • 控制反转 IoC , 面向切面 Aop
  • 支持 事务

一句话概括：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

2、IOC

参考：

https://blog.csdn.net/weixin_45842494/article/details/122772824?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171930621116800227431608%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=171930621116800227431608&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~times_rank-12-122772824-null-null.nonecase&utm_term=Spring学习笔记&spm=1018.2226.3001.4450

3、applicationContext

https://blog.csdn.net/weixin_45842494/article/details/122772913?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171930621116800227431608%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=171930621116800227431608&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~times_rank-11-122772913-null-null.nonecase&utm_term=Spring%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0&spm=1018.2226.3001.4450

4、依赖注入（DI）

https://blog.csdn.net/weixin_45842494/article/details/122775544?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171930621116800227431608%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=171930621116800227431608&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~times_rank-9-122775544-null-null.nonecase&utm_term=Spring%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0&spm=1018.2226.3001.4450

5、Bean的作用域

https://blog.csdn.net/weixin_45842494/article/details/122776494?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171930621116800227431608%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=171930621116800227431608&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~times_rank-8-122776494-null-null.nonecase&utm_term=Spring%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0&spm=1018.2226.3001.4450

6、Spring自动装配

在这里插入图片描述

https://blog.csdn.net/weixin_45842494/article/details/122777536?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171930621116800227431608%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=171930621116800227431608&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~times_rank-7-122777536-null-null.nonecase&utm_term=Spring%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0&spm=1018.2226.3001.4450

7. Spring使用注解开发

在这里插入图片描述

https://blog.csdn.net/weixin_45842494/article/details/122778659?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522171930621116800227431608%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=171930621116800227431608&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~times_rank-6-122778659-null-null.nonecase&utm_term=Spring%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0&spm=1018.2226.3001.4450

@Component的三个衍生注解

我们这些注解，就是替代了在配置文件当中配置步骤而已！更加的方便快捷！

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，目前使用哪一个功能都一样。

  • @Controller：web层
  • @Service：service层
  • @Repository：dao层
    以上这些注解，功能一样，就相当于将这个类交给Spring管理装配了！

前面写了指定注解扫描包

<context:component-scan base-package="com.xxc.pojo"/>

那如果使用了衍生注解，这些注解所在类并不完全在pojo下，这个时候，我们可以扩大指定注解扫描包的作用范围。

<context:component-scan base-package="com.xxc"/>

8、基于Java类进行配置

  1. 在User类上添加@Component注解，表示这个类标注为Spring的一个组件，放到容器中
  2. 新建一个config配置包，编写一个MyConfig配置类
    • @Configuration 注解，代表这是一个配置类。
    • 同时在user方法上注册@Bean
    • 这个方法的返回值就是Bean的class，方法名就是bean的id。
@Configuration  // 代表这是一个配置类
public class MyConfig {

    @Bean  // 注册一个bean,这里的返回值就是Bean的类型，方法名就是bean的id。
    public User user(){
        return new User();
    }
}
  1. 测试
    这里需要new AnnotationConfigApplicationContext。之前都是CPX。这里用获取注解的Context。
    getBean(“user”, User.class）其实就是获取方法名
public class MyTest {
    @Test
    public void test(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        User user = applicationContext.getBean("user", User.class);
        System.out.println(user.getName());
    }
}

9、代理模式

AOP的底层机制就是动态代理模式

分类：

  • 静态代理
  • 动态代理

在这里插入图片描述

静态代理

静态代理代理的是真实对象

静态代理角色分析

  • 抽象角色 : 一般使用接口或者抽象类来实现
  • 真实角色 : 被代理的角色
  • 代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作
  • 客户 : 使用代理角色来进行一些操作

代码实现

Rent.java 租房。即抽象角色

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

Host.java 房东。真实角色

//真实角色: 房东，房东要出租房子
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

Proxy.java 代理角色。内置private Host host;房东属性

//代理角色：中介
public class Proxy implements Rent {
    private Host host; // 中介代理的是房东，将房东作为属性

    public Proxy() {}

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

    @Override
    public void rent() {
        seeHouse();
        host.rent();
        fare();
    }

    // 看房
    public void seeHouse(){
        System.out.println("带客户看房子。");
    }

    // 收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

Client.java 客户

public class Client {
    public static void main(String[] args) {
        // 房东要出租房
        Host host = new Host();
        // 中介帮助房东
        Proxy proxy = new Proxy(host);

        // 客户找中介
        proxy.rent();
    }
}

结果：
在这里插入图片描述

分析：在这个过程中，你直接接触的是中介，但是你依然通过中介租到了房东的房子。这就是所谓的代理模式。对于房东来说很纯粹，只有租出房子，而中介可以附加一些额外的操作，比如带客户看房，收中介费等等。

静态代理的优缺点

优点

  • 可以使得我们的真实角色更加纯粹，不再去关注一些公共的事情。
  • 公共的业务由代理来完成，实现了业务的分工。
  • 公共业务发生扩展时变得更加集中和方便。

缺点

  • 一个真实的角色就会产生一个代理角色；代码量翻倍，开发效率低
  • 我们想要静态代理的好处，又不想要静态代理的缺点，所以 , 就有了动态代理 !

静态代理再理解

  1. 创建一个抽象角色，增删改查！
//抽象角色：增删改查业务
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}
  1. 我们需要一个真实对象来完成这些增删改查操作
//真实对象，完成增删改查操作的人
public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("add了一个用户");
    }

    @Override
    public void delete() {
        System.out.println("delete了一个用户");
    }

    @Override
    public void update() {
        System.out.println("update了一个用户");
    }

    @Override
    public void query() {
        System.out.println("query了一个用户");
    }
}
  1. 需求来了，现在我们需要增加一个日志功能，怎么实现?
  • 思路1 ：在实现类上增加代码 【麻烦！】
  • 思路2：使用代理来做，能够不改变原来的业务情况下，实现此功能就是最好的了！
  1. 设置一个代理类来处理日志！ 代理角色
//代理角色，在这里面增加日志的实现
public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    @Override
    public void add() {
        log("add");
        userService.add();
    }

    @Override
    public void delete() {
        log("delete");
        userService.delete();
    }

    @Override
    public void update() {
        log("update");
        userService.update();
    }

    @Override
    public void query() {
        log("query");
        userService.query();
    }

    public void log(String str){
        System.out.println("打印了"+str+"的日志");
    }
}
  1. 测试访问类：
    运用代理模式，新建一个类，实现接口，代理真实对象。
    这里使用setUserService使用了控制反转的思想，将调用权给用户。
public class Client {
    public static void main(String[] args) {
        //真实业务
        UserServiceImpl userService = new UserServiceImpl();
        //代理类
        UserServiceProxy proxy = new UserServiceProxy();
        //使用代理类实现日志功能！
        proxy.setUserService(userService);
        proxy.add();
        proxy.delete();
        proxy.update();
        proxy.query();
    }
}

我们在不改变原来的代码的情况下，实现了对原有功能的增强，这是AOP中最核心的思想。
在这里插入图片描述

动态代理

底层是反射
代理的是接口（静态代理代理的是真实对象）

  • 动态代理的角色和静态代理的一样。
  • 动态代理的代理类是动态生成的，静态代理的代理类是我们提前写好的
  • 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
    • 基于接口的动态代理----JDK动态代理
    • 基于类的动态代理–cglib
    • 现在用的比较多的是 javasist 来生成动态代理
    • 我们这里使用JDK的原生代码来实现，其余的道理都是一样的！

JDK的动态代理需要了解两个类
nvocationHandler （调用处理程序）和 Proxy（动态创建代理对象）

代码实现

抽象角色和真实角色与之前的一样！

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


//真实角色: 房东，房东要出租房子
public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房东要出租房子！");
    }
}

ProxyInvocationHandler.java代理角色

public class ProxyInvocationHandler implements InvocationHandler {

    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }

    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }
    // 看房
    public void seeHouse(){
        System.out.println("带房客看房");
    }
    // 收中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

Client.java

public class Client {
    public static void main(String[] args) {
        // 真实角色
        Host host = new Host();
        // 代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host); // 将真实角色放置进去
        Rent proxy = (Rent) pih.getProxy(); // 动态生成对应的代理类
        proxy.rent();
    }
}

核心：一个动态代理 , 一般代理某一类业务 , 一个动态代理可以代理多个类，代理的是接口！

动态代理深化理解

我们来使用动态代理实现代理我们后面写的UserService！
我们也可以编写一个通用的动态代理实现的类（相当于工具类）！所有的代理对象设置为Object即可！

ProxyInvocationHandler .java
//此时有需求：添加日志

public class ProxyInvocationHandler implements InvocationHandler {

    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object invoke = method.invoke(object, args);
        return invoke;
    }

    //此时有需求：添加日志
    public void log(String str){
        System.out.println("执行了"+str+"方法");
    }

}

Client.java

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

动态代理的好处

静态代理有的它都有，静态代理没有的，它也有！

  • 可以使得我们的真实角色更加纯粹，不再去关注一些公共的事情 .
  • 公共的业务由代理来完成，实现了业务的分工 ,
  • 公共业务发生扩展时变得更加集中和方便 .
  • 一个动态代理 , 一般代理某一类业务
  • 一个动态代理可以代理多个类，代理的是接口！

10、AOP

在这里插入图片描述

使用Spring实现AOP

  1. 通过 Spring API 实现

实现接口MethodBeforeAdvice （前置）、AfterReturningAdvice （后置）。最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束

public class BeforeLog 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()+"被执行了");
    }
}


<?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.xxc.service.UserServiceImpl"/>
    <bean id="after" class="com.xxc.log.AfterLog"/>
    <bean id="before" class="com.xxc.log.BeforeLog"/>

    <!--aop的配置-->
    <aop:config>
        <!--切入点 expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(* com.xxc.service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="before" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="after" pointcut-ref="pointcut"/>
    </aop:config>
</beans>
  1. 自定义类来实现

自定义一个类，并在配置文件中配置

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

<?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.xxc.service.UserServiceImpl"/>
    <bean id="diy" class="com.xxc.config.DiyPointcut"/>
    <aop:config>
        <aop:aspect ref="diy">
            <aop:pointcut id="diyPonitcut" expression="execution(* com.xxc.service.UserServiceImpl.*(..))"/>
            <aop:before pointcut-ref="diyPonitcut" method="before"/>
            <aop:after pointcut-ref="diyPonitcut" method="after"/>
        </aop:aspect>
    </aop:config>

</beans>
  1. 使用注解实现

编写一个注解实现的增强类，标注@Aspect、@Before(“execution(* com.xxc.service.UserServiceImpl.*(…))”)、@After、 @Around。最后配置文件中配置

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.xxc.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("---------方法执行前---------");
    }
    @After("execution(* com.xxc.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("---------方法执行后---------");
    }
    @Around("execution(* com.xxc.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);
    }
}


<?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 id="userService" class="com.xxc.service.UserServiceImpl"/>
    <bean id="annotationPointcut" class="com.xxc.config.AnnotationPointcut"/>
    <aop:aspectj-autoproxy/>
</beans>

11、整合Mybatis

https://blog.csdn.net/weixin_45842494/article/details/122793998

12、声明式事务

AOP，交给容器管理

当执行一段代码：先新增一条数据，再删除另一条数据，最后查询所有数据，此时删除中代码写错了。

如果没有事务则会出现报错提示，数据新增成功，删除失败。是有问题的，应该保证ACID原则，要么都成功要么都失败。

以前的事务都是手动开启、手动提交的，非常麻烦。
现在Spring给我们提供了事务管理，我们只需要配置即可

声明式事务的配置：

  1. 头文件导入tx：
xmlns:tx="http://www.springframework.org/schema/tx"

http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
  1. 配置事务
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
</bean>
  1. 配置事务通知
    在开发中，我们只需要配置最后的<tx:method name=“*” propagation=“REQUIRED”/>即可，这个就表示给所有方法添加了事务。
<!--配置事务通知-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <!--配置哪些方法使用什么样的事务,配置事务的传播特性-->
        <tx:method name="add" propagation="REQUIRED"/>
        <tx:method name="delete" propagation="REQUIRED"/>
        <tx:method name="update" propagation="REQUIRED"/>
        <tx:method name="search*" propagation="REQUIRED"/>
        <tx:method name="get" read-only="true"/>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
  1. 配置aop织入
<!--配置aop织入事务-->
<aop:config>
    <aop:pointcut id="txPointcut" expression="execution(* com.xxc.dao.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>

此时的结果： 还是会报异常，但是数据并没有插入，达到了我们想要的效果。

还有一种编程式事务，其原理就是加上trycatch，报错调用回滚

zhaozhao_1
关注
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
SpringMVC+Spring+Mybatis集成开发环境
04-28
在IT行业中，SpringMVC、Spring和Mybatis是三大核心框架，它们的集成使用是Java Web开发中的常见实践。这个集成开发环境旨在提供一个高效、灵活的开发平台，以实现业务逻辑与数据访问的分离，提高代码的可维护性和可...
微服务架构Spring Cloud概述和基本讲解
热门推荐
张彦峰的博客
02-14 164万+
微服务架构Spring Cloud概述和基本讲解
Spring入门第一讲——Spring框架的快速入门
李阿昀的博客
04-08 14万+
Spring的概述什么是Spring据度娘所载： Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson创建。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。 Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Exp
SpringCache
weixin_47409774的博客
03-17 1万+
Spring 从3.1 开始定义了org.springframework.cache.Cache 和org.springframework.cache.CacheManager 接口来统一不同的缓存技术； 并支持使用JCache（JSR-107）注解简化我们开发； Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合； Cache 接口下Spring 提供了各种xxxCache 的实现； 如RedisCache ， EhCacheCache , ConcurrentMapCache 等； .
Spring AI -使用Spring快速开发ChatGPT应用
qq_41481367的博客
11-08 2万+
本篇文章将会对SpringAI进行简单的介绍和使用，并通过SpringBoot来集成SpringAI实际开发出一个简单的http对话接口。
Spring框架
m0_51457307的博客
11-20 1万+
一、Spring概述 Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有很高的凝聚力#%E4%B8%80%E3%80%81Spring%E6%A6%82%E8%BF%B0和吸引力。
解救应用启动危机：Spring Boot的FailureAnalyzer机制
张彦峰的博客
05-02 2万+
探讨Spring Boot中的FailureAnalyzer机制，帮助解决应用启动失败的难题。对FailureAnalyzer的工作原理、生效方式以及自定义的基本步骤进行介绍，包括注册方式说明和实例演示。希望可以帮助更好地理解并利用FailureAnalyzer来诊断和解决应用启动失败的问题。
SpringSecurity自定义登录界面
weixin_43472934的博客
04-18 6750
为什么需要自定义登录界面？ 答：因为SpringBoot整合SpringSecurity时，只需要一个依赖，无需其他配置，就可以实现认证功能。但是它的认证登录界面是固定那样的，如下图所示，但是我们希望自己搞个好看的登录界面，所以需要自定义登录界面。 第一步：创建springboot项目 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
【Spring进阶系列丨第八篇】Spring整合junit & 面向切面编程(AOP)详解
陈橘又青的博客
04-10 1万+
是Endava的专职开发主管和培训师，他负责欧洲、美国和亚洲客户的金融市场项目开发。他有超过10年的开发经验。Laurenţiu相信，重要的不仅是交付高质量的软件，还要分享知识和帮助他人提升技能。这些信念驱使他去设计和讲授与Java技术相关的课程，并进行演示和参与研讨会。
【微服务】Spring Cloud Bus的注意事项和常用案例
Venus's Blog
07-24 2万+
Spring Cloud Bus 是一个强大的工具，能够在分布式系统中实现配置同步和事件广播，有效提高系统的灵活性和可维护性。通过选择合适的消息代理、配置持久化和安全措施、保证消息处理的幂等性、建立健全的错误处理机制，并进行充分的测试和日志记录，可以确保 Spring Cloud Bus 的高效运行。无论是实现配置的动态同步，还是在服务之间广播事件，Spring Cloud Bus 都能显著提升微服务架构的可靠性和可扩展性。强烈推荐。
Spring Boot 企业级开发课后题答案
文轩
07-04 2万+
Spring Boot 企业级开发课后题答案 黑马程序员 加粗字体为答案 第一章 1.1 填空题 Pivotal 团队在原有 spring 框架的基础上开发了全新的Spring Boot框架。 Spring Boot框架在开发过程中大量使用 约定优先配置 的思想来摆脱框架中各种复杂的手动配置。 Spring Boot 2.1.3版本要求Java 8 及以上版本的支持。 Spring Boot2.1.3版本框架官方声明支持的第三方项目构建工具包括有 maven(3.3+) 和 gradle(4.4+.
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
项目原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6 二、 项目目的： 整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + ...
Spring+SpringMVC+MyBatis整合工程实例 完整版源码（带注释）
07-19
SSM框架整合是指Spring、SpringMVC和MyBatis三个开源框架的集成，常用于构建企业级的Java Web应用程序。这三个框架各有其优势，Spring负责控制层，SpringMVC处理视图和业务逻辑，而MyBatis则专注于数据库操作。 **1...
第三章 SpringBoot项目构建 - 整合Spring Security入门
想做一个小孩的杨先生的博客
09-11 554
Spring Security 是一个强大的框架，用于保护基于 Spring 的应用程序。它提供了全面的认证和授权功能，使得安全机制与应用逻辑相分离。以下是 Spring Security 的基本使用指南，包括如何集成 Spring Security、定义用户角色和权限、以及自定义安全配置。在 Java 生态中，目前有 Spring Security 和 Apache Shiro 两个安全框架，可以完成认证和授权的功能。
SpringCloud入门（一）SpringCloud简介
kong7906928的博客
09-11 1170
springcloud知识框架，springcloud学习路线
滚雪球学SpringCloud[2.2]：Consul与Zookeeper服务注册
**My Coding Family**
09-14 802
在上一节【2.1 服务注册中心Eureka】中，我们探讨了 Netflix 开源的服务注册中心 Eureka 的核心概念及其在微服务架构中的应用。Eureka 通过提供服务注册与发现功能，帮助微服务之间高效通信，并且具备高可用性和扩展性。虽然 Eureka 在微服务架构中应用广泛，但并不是唯一的解决方案。除了 Eureka，还有其他非常优秀的服务注册中心，如Consul和Zookeeper，它们在不同的场景下各有优势。本节将详细介绍Consul和Zookeeper。
房产销售系统开发：SpringBoot技术要点
最新发布
2401_85341950的博客
09-14 782
首页、房源信息、个人中心、后台管理等功能，这给管理者的工作带来了巨大的挑战，面对大量的信息，传统的管理系统，都是通过笔记的方式进行详细信息的统计，后来出现电脑，通过电脑输入软件将纸质的信息统计到电脑上，这种方式比较传统，而且想要统计数据信息比较麻烦，还受时间和空间的影响，所以为此开发了房产销售系统；Tomcat是非常受欢迎的服务器，因为它具有较好的扩展性，而且在运行的时候不需要太多的系统资源，拥有程序员所需要的收发邮件功能，还能够支持负载平衡，该程序能够不断的更新，程序员能够根据自己的需要增加新的功能。
SpringBoot 项目 Jar 包加密，防止反编译
牧竹子
09-13 692
在单模块中此方案还算简单，但是现在项目一般都是多模块，一个模块依赖多个公共模块。那么使用此方案就比较麻烦，配置复杂，文档难懂，各模块之间的调用在是否混淆时极其容易出错。要求对正式环境的启动包进行安全性处理，防止客户直接通过反编译工具将代码反编译出来。只需要在启动类的pom.xml文件中加如下插件即可，需要注意的是，改插件时要放到spring-boot-maven-plugin插件后面，否则不起作用。启动包加密之后，方法体被清空,保留方法参数、注解等信息.主要兼容swagger文档注解扫描。
Spring实践指南
"Spring in Practice" 是一本关于Spring框架的实践指南，类似于"Spring in Action"，适合有一定英文基础的读者阅读。本书由Willie Wheeler和Joshua White合作撰写，覆盖了Spring 3版本的内容。 在Spring框架的实践...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值