Spring---AOP、整合MyBatis、声明事务

最新推荐文章于 2024-07-26 00:55:46 发布
最新推荐文章于 2024-07-26 00:55:46 发布
阅读量194 收藏
点赞数
分类专栏： SSM 文章标签： spring mybatis aop 整合mybatis 声明事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love_to_share/article/details/104512458
版权

1.代理模式
2.AOP
3.整合MyBatis
4.声明事务

1.代理模式

1.1静态代理

用一个中介代替我们去做一些事情。

  • 抽象角色 ：一般会使用接口或者抽象类来解决
  • 真实角色 ：被代理的角色
  • 代理角色 ：代理真实角色 ， 代理真实角色后，我们一般会做一些附属操作
  • 客户 ： 访问代理对象的人！

比如拿租房这件事举例子

  1. 接口
   //租房
   public interface Rent {
   
       public void rent();
   
   }
  1. 真实角色
java
   //房东
   public class Host implements Rent {
   
       public void rent() {
           System.out.println("房东要出租房子！");
       }
   }
  1. 代理角色
java
   public class Proxy implements Rent {
   
       private Host host;
   
       public Proxy() {
       }
       public Proxy(Host host) {
           this.host = host;
       }
   
   
       public void rent() {
           seeHouse();
           host.rent();
           hetong();
           fare();
       }
   
       //看房
       public void seeHouse(){
           System.out.println("中介带你看房");
       }
   
       //看房
       public void hetong(){
           System.out.println("签租赁合同");
       }
       //收中介费
       public void fare(){
           System.out.println("收中介费");
       }
   
   }
  1. 客户端访问代理角色
 public class Client {
       public static void main(String[] args) {
           //房东要租房子
           Host host = new Host();
           //代理，中介帮房东租房子，但是呢？代理角一般会有一些附属操作！
           Proxy proxy = new Proxy(host);
   
           //你不用面对房东，直接找中介租房即可！
           proxy.rent();
       }
   }

代理模式的好处：

  • 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
  • 公共也就就交给代理角色！实现了业务的分工！
  • 公共业务发生扩展的时候，方便集中管理！

缺点：

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

1.2动态代理

  • 动态代理和静态代理角色一样
  • 动态代理的代理类是动态生成的，不是我们直接写好的！
  • 动态代理分为两大类 ： 基于接口的动态代理 ， 基于类的动态代理
    • 基于接口 — JDK 动态代理 【我们在这里使用】
    • 基于类 ： cglib
    • java字节码实现 ： javasist

动态代理的好处：

  • 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
  • 公共也就就交给代理角色！实现了业务的分工！
  • 公共业务发生扩展的时候，方便集中管理！
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务
  • 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

2.AOP

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

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

方式一：使用Spring的API 接口

1、导入依赖

        <!--aop aspectjweaver-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

2、抽象角色：增删改查 用接口来实现

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

3、真实对象：实现增删改查方法，

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加用户");
    }

    public void delete() {
        System.out.println("删除用户");
    }

    public void update() {
        System.out.println("更新用户");
    }

    public void search() {
        System.out.println("查询用户");
    }
}

4、增强类：

//Advice前置
public class Log implements MethodBeforeAdvice {
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法被执行了");
    }
}

public class LogAfter implements AfterReturningAdvice {
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"方法，返回了"+returnValue);
    }
}

5、xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
         http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
<aop:config>
    <!--切入点，哪些方法要被增强-->
    <aop:pointcut id="pc-userservice" expression="execution(* com.yang.service.UserServiceImpl.*(..))"/>
    <aop:advisor advice-ref="log" pointcut-ref="pc-userservice"/>
    <aop:advisor advice-ref="afterlog" pointcut-ref="pc-userservice"/>
</aop:config>
</beans>

6、测试

    @Test
    public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }

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

方式二：自定义实现

还是上一个案例，增加一个切面类，也就是自定义一个类，把这个类注册到xml中。
1、自定义类

public class Diy {
    //aop配置第二种方式，自定义实现   这就是一个切面  一个自定义类
    public void before(){
        System.out.println("方法执行前");
    }
    public void after(){
        System.out.println("方法执行后");
    }
}

2、xml配置

    <bean id="diy" class="com.yang.config.Diy"/>
    <aop:config>
        <!--方式二-->
        <!--配置切面,就需要配置标签增强-->
        <aop:aspect ref="diy">
         <aop:pointcut id="pc-userservice" expression="execution(* com.yang.service.UserServiceImpl.*(..))"/>
         <aop:before method="before" pointcut-ref="pc-userservice"/>
         <aop:after method="after" pointcut-ref="pc-userservice"/>
        </aop:aspect>
    </aop:config>

3、测试方法不变 ，结果如下
在这里插入图片描述

方式三：使用注解实现

增加一个类，在里面添加注解，然后配置这个类到xml中
1、注解方法

//aop配置第三种方式  使用注解实现
@Aspect
public class AnnotationPoint {
    @Before("execution(* com.yang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("====方法执行前====");
    }
    @After("execution(* com.yang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("====方法执行后====");
    }
    @Around("execution(* com.yang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint joinPoint)throws Throwable{
        System.out.println("======环绕前============");
        joinPoint.proceed();//执行方法
        System.out.println("==============环绕后===========");
    }
}

2、xml配置

    <bean id="AnnotationPoint" class="com.yang.config.AnnotationPoint"/>
    <aop:aspectj-autoproxy/>

3、测试结果
在这里插入图片描述

3.整合MyBatis

先写出第一个mybatis’程序，引入spring

一、mybatis’程序

1、导包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>spring02</groupId>
    <artifactId>spring02</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--Spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
        <!--Spring jdbc(new)-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>
        <!--aop aspectjweaver-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <!--mybatis-spring-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>

    </dependencies>

    <!-- 如果xml在java文件下，就要设置资源过滤-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

</project>

2、实体类

//实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String name;
    private String pwd;
}

3、接口

public interface UserMapper {
    public List<User> getUserList();
}

4、接口对应xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yang.mapper.UserMapper">

    <select id="getUserList" resultType="User">
        select * from user
    </select>
</mapper>

5、全局xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  
  <!-- 一个environments 标签元素可以有多套配置 -->
    <environments default="development">
        <!-- 里面的每一个environment代表一个具体的环境 -->
        <environment id="development">
            <!--transactionManager 事务管理器 -->
            <transactionManager type="JDBC"/>
            <!-- dataSource 数据源配置 -->
            <dataSource type="POOLED">
                <!-- 连接数据库的配置i-->
		<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/yang/mapper/xml/UserMapper.xml"/>

    </mappers>

</configuration>

6、测试

    @SneakyThrows
    @Test
    public void test() throws IOException {
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        for (User user : mapper.getUserList()) {
            System.out.println(user);
        }
    }

二、引入spring

1、编写配置文件

<!--整合mybatis-->

    <!--1、整合数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <!--2、注入 SqlSessionFactory-->
    <bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--扫描包-->
        <property name="configLocation" value="classpath:mybatis.xml"/>
        <property name="mapperLocations" value="classpath:com/yang/mapper/xml/*.xml"/>

    </bean>

    <!--3、创建SqlSession-->
    <bean id="SqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="SqlSessionFactory"/>
    </bean>
    <!--4、SqlSession放入bean-->
 <bean id="UserMapperImpl" class="com.yang.impl.UserMapperImpl">
     <property name="sqlSession" ref="SqlSession"/>
 </bean>

2、实现类

public class UserMapperImpl implements UserMapper {

    //注入SqlSession；spring管理
    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    public List<User> getUserList() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUserList();
    }
}

3、测试

    @Test
    public void test1() throws IOException {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapperImpl = (UserMapper) context.getBean("UserMapperImpl");
        for (User user : userMapperImpl.getUserList()) {
            System.out.println(user);
        }
    }

4.声明事务

事务在项目开发中，十分的重要，涉及到数据的一致性问题；把一组业务当成一个业务来做；要么都成功，要么都失败！

ACID原则：

  • 原子性
  • 一致性
  • 隔离性
    • 多个业务可能操作同一个资源，防止数据损坏
  • 持久性
    • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中！

代码实现
1、增加一个新增和删除用户方法

public interface UserMapper {
    public List<User> getUserList();
    //添加一个用户
    public int addUser(User user);

    //删除一个用户
    public int deleteUser(int id);
}

2、编写sql时候，故意写错一个

    <select id="getUserList" resultType="user">
        select * from user
    </select>

    <insert id="addUser" parameterType="user">
        insert into user (id, name, pwd) values (#{id}, #{name}, #{pwd});
    </insert>

    <delete id="deleteUser" parameterType="int">
        deletes from user where id=#{id}  <!--这句sql故意写错-->
    </delete>

3、编写实现类

public class UserMapperImpl implements UserMapper {
    //注入SqlSession；spring管理
    private SqlSessionTemplate sqlSession;
    public List<User> getUserList() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User(5, "lisi", "123456");
        mapper.addUser(user);
        mapper.deleteUser(4);
        return mapper.getUserList();
    }

    public int addUser(User user) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.addUser(user);
    }

    public int deleteUser(int id) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.deleteUser(id);
    }
}

4、测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
        List<User> userList = userMapper.selectUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }
}

虽然一个sql失败了，但是另一个成功了，但是这两个事务在同一个方法中，这样是不对的
5、配置spring事务管理

   <!--整合事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

 <!--实物配置增强-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--AOP配置事务切入-->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.yang.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>

6、再次测试，看事务是否生效

刘心芝士小蛋糕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring（四）--------AOP、整合Mybatis、声明式事务
钟情_的博客
09-02 253
Spring（四）--------AOP、整合Mybatis、声明式事务 11、AOP（重点） 11.1 什么是AOP 总的来说：AOP是在不影响原始业务类的情况下，对代码进行动态的增强 AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务
spring-mybatis整合jar包，spring-mybatis整合jar包
03-17
Spring Mybatis是一个流行的...通过以上库文件的整合，Spring Mybatis能提供一套完整的解决方案，帮助开发者快速、高效地构建数据访问层，同时利用Spring的其他功能如事务管理、AOP等，提高代码的可维护性和灵活性。
Spring AOP的MyBatis事务管理
无心
04-07 977
XML方式配置 环境搭建 Maven依赖 <!--mybatis的依赖--> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.24</version> </dependency> <dependency>
spring+mybatis配置aop事务
babiaooj811950的博客
07-25 433
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> <tx:...
SpringMVC、MyBatis声明式事务管理
yinhong2006的专栏
10-23 213
SpringMVC、MyBatis声明式事务管理 博客分类：  SpringMvc SpringMVCMybatis声明式事务  采用的基本搭建环境：SpringMVC、MyBatis、MySQL、tomcat         Spring事务管理分解了传统的全局事务管理和本地事务管理的劣势，使得在任何环境中都可以使用统一的事务管理模型，你可以写一次代码，然后在不...
spring_mybatis_spring-mybatis_
10-02
Spring MyBatis 模板是为初学者设计的一个基础项目框架，它整合了Spring和MyBatis两大流行框架，帮助开发者快速搭建一个可运行的Web应用。本文将深入讲解Spring MyBatis集成的关键知识点，包括Spring框架的核心概念...
ssm-spring-security-Aop.zip
09-05
【标题】"ssm-spring-security-Aop.zip" 涉及的核心技术是Spring Security与AOP在SSM（Spring、SpringMVC、MyBatis）框架中的集成应用，主要目的是实现安全登录功能并利用AOP进行日志记录并存入数据库。 【描述】...
spring-mybatis:spring 整合 mybatis
05-19
三、Spring整合MyBatis的关键步骤 1. 使用`@MapperScan`注解扫描Mapper接口：在Spring配置类上添加此注解，以便Spring自动发现并管理Mapper接口。 ```java @Configuration @MapperScan("com.example.mapper") ...
MyBatis集合Spring（四）之使用Spring处理事务
owen_william的博客
07-03 1万+
1. Spring事务处理 使用MyBatis,你可以写代码去控制事务操作。例如，提交事务和回滚事务。 public Student createStudent(Student student) { SqlSession sqlSession = MyBatisUtil.getSqlSessionFactory(). openSession(); try { StudentMapper map
Spring之XML 配置AOP 事务管理
专注于Java领域开发 关注我 带你玩转Java
12-07 853
XML中配置AOP 切面类 正常写通知 不用加注解 public class MyAspect { //前置通知 public void mybefore(){ System.out.println("前置通知"); } //后置通知 public void myaftereturning(Object obj){ System.out.println("后置通知"); } //环绕通知 ....
mybatis通过@After和@Before提取重复代码
weixin_44682587的博客
07-31 1217
对于一些重复执行的代码，也就是逻辑之前的初始化，可以写进before()和after()方法中执行，代表程序刚开始执行before(),最后执行after(),中间执行逻辑代码。 package com.gyf.test; import com.gyf.model.User; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.SqlSession; import org.apache.ibatis.session
Spring声明式事务
高朗的博客
09-21 226
文章目录一、回顾事务二、Spring声明式事务 一、回顾事务 把一组业务当成一个业务来做;要么都成功，要么都失败。 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎。 确保完整性和一致性。 事务ACID原则： 原子性 一致性 隔离性（多个业务可能操作同一个资源，防止数据损坏） 持久性（事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化的写到存储器中） public class MyTest { @Test public void test() {
spring+mybatis事务配置
热门推荐
心相印的专栏
10-19 2万+
申明式事务配置步骤 1、xml文件头部需要添加spring的相关支持：<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org
SSM进阶（四）Spring整合Mybatis-----Aop事务
qq_42112846的博客
06-29 2144
Spring整合Mybatis-----Aop事务   首先对于Spring整合Mybatis有两种方式那就是使用sql绝对定位以及使用Mapper代理来进行开发，本篇博文先来介绍第一种。          所谓的Sql绝对定位就是namespace+id得方式来进行定位； 首先对于Mybatis得介绍后面会有博文详细介绍，简单的说Mybatis得核心配置文件完成得就两个功能，一就是数据...
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 217
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
【过滤器 vs 拦截器】SpringBoot中过滤器与拦截器：明智选择的艺术（如何在项目中做出明智选择）
weixin_68020300的博客
07-25 993
本文深入剖析了SpringBoot框架下过滤器与拦截器的核心差异及应用场景，指导开发者在面对请求-响应周期中的不同需求时，如何做出最佳技术选择。无论是实现安全性、日志记录，还是权限控制与数据预处理，本文都将帮助你理解何时何地使用过滤器或拦截器，以构建更加高效、可维护的Web应用程序。通过对比二者的特性与优劣，本文旨在赋能开发者，使其在实际项目中灵活运用这两种强大工具，达成项目目标。
【Spring Framework】使用完全注解方式开发
最新发布
u013675821的博客
07-26 985
本文介绍了如何使用 Spring 完全注解化的方式来进行开发。通过使用注解，我们可以减少 XML 配置文件的使用，使项目的配置更加直观和简洁。配置类：使用@Bean等注解定义配置类。数据库配置：使用DataSource以及@Autowired自动装配数据源。服务层和控制器层：使用@Service和注解定义业务逻辑和控制器，并使用@Autowired注入依赖。AOP 和事务管理：通过@Aspect和注解实现日志记录和事务管理。
MyBatis-Spring整合指南
"mybatis-spring集成 - 将MyBatis与Spring无缝结合，提供事务管理、异常转换等功能，适用于Java 5及以上版本，需要熟悉Spring和MyBatis基础" 在Java开发领域，MyBatis和Spring是两个非常重要的框架。MyBatis是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值