简单使用spring

最新推荐文章于 2024-09-21 00:43:01 发布
最新推荐文章于 2024-09-21 00:43:01 发布
阅读量608 收藏 12
点赞数 6
分类专栏： spring IOC spring AOP spring 连接mybatis 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/isWeisen/article/details/102380328
版权

文章目录

什么是Spring

Spring简介

Spring框架是个轻量级的Java EE框架。所谓轻量级，是指不依赖于容器就能运行的。Struts、Hibernate也是轻量级的。
　　轻量级框架是相对于重量级框架而言的，重量级框架必须依赖特定的容器
　　Spring以IoC、AOP为主要思想，其中IoC，Inversion of Control 指控制反转或反向控制。在Spring框架中我们通过配置创建类对象，由Spring在运行阶段实例化、组装对象。AOP，Aspect Oriented Programming，面向切面编程，其思想是在执行某些代码前执行另外的代码，使程序更灵活、扩展性更好，可以随便地添加、删除某些功能。Servlet中的Filter便是一种AOP思想的实现。
　　Spring同时也是一个“一站式”框架，即Spring在JavaEE的三层架构[表现层(Controller层)、业务逻辑层（Service层）、数据访问层（DAO层）]中，每一层均提供了不同的解决技术

spring三层

  1. 表现层（Controller层）：Spring MVC
  2. 业务逻辑层（Service层）：Spring的IoC
  3. 数据访问层（DAO层）：支持mybaits，hibernate，封装jdbc

Spring 的优势

  1. 低侵入 / 低耦合 （降低组件之间的耦合度，实现软件各层之间的解耦）
  2. 声明式事务管理（基于切面和惯例）
  3. 方便集成其他框架（如MyBatis、Hibernate）
  4. 降低 Java 开发难度
  5. Spring 框架中包括了 J2EE 三层的每一层的解决方案

spring的核心

  1. IOC:（Inverse of Control 控制反转）：将对象的创建权,交由Spring完成
    1. DI：依赖注入：依赖注入可以说是控制反转的一个具体实现例子，其在Spring中的体现在于组件之间的依赖关系由容器控制，我们通过简单的配置，不通过代码就可以得到指定的资源。
  2. AOP : Aspect Oriented Programming 是 面向对象的功能延伸.不是替换面向对象,是用来解决OO中一些问题

spring IoC

控制反转 ，也叫依赖注入，是面向对象编程中的一种设计理念，用来降低程序代码之间的耦合度。将创建对象的权力交给容器。

使用的步骤

1. 通过maven导入spring核心jar

<!--spring start-->
    <!-- spring-beans -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

    <!--spring-core -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

    <!-- spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

    <!-- spring-expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

    <!-- commons-logging -->
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>

    <!--spring end-->

2. 创建配置文件 spring-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">
    <!-- 定义第一个Bean实例：bean1 -->
     <bean id="..." class="...">
        
    </bean>

</beans>
  1. spring-config.xml的元素

    1. beans：

      ​ beans元素是Spring配置文件的根元素

    2. bean：

      ​ bean元素是Spring配置文件的beans元素的子元素，beans元素可以包含多个bean子元素，每个bean元素相当于定义了一个实例,相当于容器创建了一个对象；定义bean时通常需要指定两个属性

      • ​ id：确定该Bean的唯一标识符，容器对Bean管理、访问、以及该Bean的依赖关系，都通过该属性完成。 Bean的id属性在Spring容器中是唯一的。
      • class：指定该Bean的具体实现类。注意这里不能使接口。通常情况下，Spring会直接使用new关键字创建该Bean的实例，因此，这里必须提供Bean实现类的类名。
  2. 创建一个bean

    1. 创建一个bean类

      package cn.pojo;

import java.io.Serializable;
import java.util.Date;

public class News implements Serializable{
	private Integer id;//ID
	private String title;//标题
	private String content;//内容
	private Date createTime;//创建时间
    
    public News() {}

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	public Date getCreateTime() {
		return createTime;
	}

	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}
}

    2. 配置spring-config.xml文件

      • 当我们在配置文件中通过方法配置一个Bean时，这样就需要该Bean实现类中必须有一个无参构造器。
      <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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">
     <bean id="news" class="cn.pojo.News"></bean>
</beans>
      • 在配置的时候我们还可以给这个Bean类中的属性赋值，通过bean的子元素property实现spring中的setter注入方式
      <bean id="news" class="cn.pojo.News">
    <!-- 给名字为id的属性赋值 1 -->
     <!--（将nama中的值的前面加上set，然后将首字母变为大写 变成setId,从而找到id的set方法来给id赋值） -->
    <property name="id" value="1"/>
    <!-- 可通过ref 引入其余的bean 给对象属性赋值 -->
    <property name="属性名" ref="bean"/>
</bean>

      多种方式实现依赖注入

      1. 构造注入：

        ​ 使用构造函数注入：添加构造函数（前提是这个构造函数存在）

        //在News类中添加id的构造函数
public News(Integer id) {
		this.id = id;
	}

         <!-- 使用构造函数配置 -->
<bean id="news" class="cn.pojo.News">
    <!-- 给构造函数的第一个参数赋值 1 -->
    <constructor-arg><value>345</value></constructor-arg>
    <!-- 也可以是通过index指定给构造函数的第几个参数赋值 1 -->
    <constructor-arg index='1'><value>345</value></constructor-arg>
</bean>

        给构造函数的参数赋值的顺序是根据前后顺序来的，也可通过参数index指定

      2. p命名空间注入

        ​ 先配置xml文件的beans的属性

         <!-- 加在beans元素上 -->
xmlns:p="http://www.springframework.org/schema/p"

        <bean id="news" class="cn.pojo.News" p:id='1'></bean>

      3. 注入特殊符号
        使用<![CDATA[值]]>：将值里的特殊字符转换成纯文字

3. 测试

public class TestNews {
    
	@Test
	public void test01()
	{
		//1.获取spring配置文件
		 ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
		 //2.由配置文件返回对象,使用getBean方法指定id获取
		 News news = (News)context.getBean("news");
		 System.out.println(news.getId());
	}
}

通过注解实现IoC的配置

1. 在Bean类上定义注解

package cn.biz.impl;


import cn.biz.OrderBiz;
import cn.mapper.order.OrderDetailMapper;
import cn.mapper.order.OrderMapper;
import cn.pojo.Order;
import cn.pojo.OrderDetail;
import com.github.pagehelper.PageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service("orderBiz")
public class OrderBizImpl implements OrderBiz {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private OrderDetailMapper orderDetailMapper;

    @Override
    public Integer add(Order order, OrderDetail orderDetail) throws Exception {
        orderMapper.add(order);
        orderDetail.setOrderId(order.getId());
        return orderDetailMapper.add(orderDetail);
    }

    public OrderMapper getOrderMapper() {
        return orderMapper;
    }

    public void setOrderMapper(OrderMapper orderMapper) {
        this.orderMapper = orderMapper;
    }

}

@Component是定义任意层的注解

而Spring提供了三个特殊的注解

  1. @Repository：用于标注Dao类
  2. @Service：用于标注业务类
  3. @Controller：用于标注控制器类

使用这些注解来定义，将相当于在spring中定义了一个

<bean id="orderController" class="cn.Controller.OrderController"></bean>

注解后面的括号是用于指定bean的id

2. 配置spring-config.xml，扫描这些注解

  1. 首先将添加beans的context

  2. 定义扫描注解的范围

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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">
    <!-- 指定扫描的范围 -->
	<context:component-scan base-package="cn.biz,cn.aop,cn.controller"/>
</beans>

3. 使用注解实现Bean组件的装配

  1. spring注解完成装配
    spring提供了@Autowired注解实现Bean的装配
    若容器中有一个以上的类型相匹配的Bean时，则可以使用 @Qualifier()指定所需要的Bean名称

    package cn.controller;

import cn.biz.OrderBiz;
import cn.pojo.Order;
import cn.pojo.OrderDetail;
import org.omg.CORBA.INTERNAL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import java.util.List;

/**
 * 作者：weisen
 * 日期：2019/9/27 19:24
 */
@Controller("orderController")
public class OrderController {

    @Autowired
    @Qualifier("orderBiz")
    private OrderBiz orderBiz;

    public List<Order> getOrderList(Integer userId){
        return orderBiz.getOrderList(userId);
    }
}

  2. 使用Java标准注解完成装配
    @Resource(name = “”)
    @Resource的name属性，默认情况下，Spring将这个属性的值解释为要注入的Bean的名称

    package cn.controller;

import cn.biz.OrderBiz;
import cn.pojo.Order;
import cn.pojo.OrderDetail;
import org.omg.CORBA.INTERNAL;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import java.util.List;

/**
 * 作者：weisen
 * 日期：2019/9/27 19:24
 */
@Controller("orderController")
public class OrderController {

    @Resource(name = "orderBiz")
    private OrderBiz orderBiz;

    public List<Order> getOrderList(Integer userId){
        return orderBiz.getOrderList(userId);
    }
}

4. 测试

public class Test {
    
	@Test
	public void test01()
	{
		//1.获取spring配置文件
		 ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
		 //2.由配置文件返回对象,使用getBean方法指定id获取
		 OrderController news = (OrderController)context.getBean("orderController");
		
	}
}

Spring AOP

什么是AOP

AOP 即 Aspect Oriented Program 面向切面编程 是一种面向切面编程的编程思路 但是spring AOP只是AOP的一种简化版

spring AOP 的目的

将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

spring AOP 当中的概念：

  • 切面（Aspect）
    切面 = 切入点 + 通知，通俗点就是：在什么时机，什么地方，做什么增强！
  • 连接点（Join Point）：程序执行中的某个具体的执行点。
  • 增强处理（Advice）：切面在某个特定的连接点上执行的代码逻辑。
  • 切入点（Pointcut）
    在哪些类，哪些方法上切入（where）
  • 织入（Weaving）
    把切面加入到对象，并创建出代理对象的过程。（由 Spring 来完成）

使用spring AOP的步骤

1. 导入jar

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

    <!-- spring-aop -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

    <!--aopalliance -->
    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
<!--spring-aop end-->

2.定义切面

创建类定义切面

public class beforeLogger {
    private Logger log  = Logger.getLogger(beforeLogger.class);
    //定义切面
    public void brfore(){
        log.info("方法执行之前");
    }
}

3. 配置spring-config.xml文件

<!--定义切面的Bean-->
<bean id="beforeLogger" class="aop.beforeLogger"></bean>
<!--配置切入信息-->
<aop:config>
    <!--定义切入点-->
      <aop:pointcut id="pointcut" expression="execution(* service.UserServiceImpl.*(..))"/>
      <aop:aspect ref="beforeLogger">
      <!--织入-->
          <!--前置增强-->
          <!--在执行方法之前会执行 brfore（）方法-->
          <aop:before method="brfore" pointcut-ref="pointcut" throwing="e"></aop:before>
          <!--后置增强：在执行方法（正常执行完成后）后调用 
				returning 指定为名为result的参数注入返回值-->
          <aop:after-returning method="afterReturning"
                pointcut-ref="pointcut" returning="result">
          </aop:after-returning>
          <!--后置增强：在执行方法（正常执行完成后）后调用 
				returning 指定为名为result的参数注入返回值-->
          <aop:after-returning method="afterReturning"
                pointcut-ref="pointcut" returning="result">
          </aop:after-returning>
          <!--  异常抛出增强：执行方法异常时执行
				throwing 指定为名为e的异常注入返回值-->
           <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" 				 			throwing="e">
          </aop:after-throwing>
          <!--  最终增强：无论方法时正常还是异常退出都会执行
				returning 指定为名为result的参数注入返回值-->
          <aop:after method="afterReturning"
                pointcut-ref="pointcut" returning="result"></aop:after>
      </aop:aspect>
</aop:config>

除了之前的单个功能的增强，还有一种包含了多数的增强的 环绕增强

  1. 定义环绕增强切面
public class ArroundLogger {
    private static final Logger log = Logger.getLogger(ArroundLogger.class);
    public Object arroundLogger(ProceedingJoinPoint jp) throws Throwable {
        log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName() + "方法。方法入参" + Arrays.toString(jp.getArgs()));
        try {
            Object result = jp.proceed();
            log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName() + "方法。方法返回值" + result);
            return result;
        } catch (Throwable e) {
            log.error(jp.getSignature().getName() + "方法发生异常：" + e);
            e.printStackTrace();
            throw e;
        } finally {
            log.info(jp.getSignature().getName() + "方法结束执行");
        }
    }
}

  1. 使用环绕增强

    <aop:around method="arroundLogger" pointcut-ref="pointcut"></aop:around>

通过注解使用AOP

1. 定义注解

import org.apache.log4j.Logger;
import org.aspectj.lang.annotation.Aspect;
//使用 @Aspect 注解将beforeLogger定义为切面
@Aspect
public class beforeLogger {
    
    private Logger log  = Logger.getLogger(beforeLogger.class);
    
    
    //前置增强注解
    @Before("execution(* action.UserAction.*(..))")
    public void brfore(){
        log.info("方法执行之前");
    }
    
    //最终增强注解
     @After("execution(* action.UserAction.*(..))")
    public void afterLogger(JoinPoint jp){
        log.info(jp.getSignature().getName()+"方法结束执行");
    }
    
    //后置增强注解
     @AfterThrowing(pointcut = "execution(* action.UserAction.*(..))",throwing = "e")
    public void afterThrowing(JoinPoint jp,RuntimeException e){
        log.error(jp.getSignature().getName()+"犯法发生异常："+e);
    }
    
    //环绕增强注解
     @Around("execution(* action.UserAction.*(..))")
    public Object arroundLogger(ProceedingJoinPoint jp) throws Throwable {
        log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName() + "方法。方法入参" + Arrays.toString(jp.getArgs()));
        try {
            Object result = jp.proceed();
            log.info("调用" + jp.getTarget() + "的" + jp.getSignature().getName() + "方法。方法返回值" + result);
            return result;
        } catch (Throwable e) {
            log.error(jp.getSignature().getName() + "方法发生异常：" + e);
            e.printStackTrace();
            throw e;
        } finally {
            log.info(jp.getSignature().getName() + "方法结束执行");
        }
    }
    
    //定义切入点
 	@Pointcut("execution(* action.UserAction.*(..))")
 	public void pointcut(){}
    
    //通过引用定义的切入点，使用增强
     @AfterReturning(pointcut = "pointcut()",returning = "result")
   	 public void afterReturning01(JoinPoint jp,Object result){
        log.info("调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法。方法入参："+result);
    }
}

2. 配置xml文件 ，扫描注解，并且启动AOP注解

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
 http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
   <!-- 扫描注解 -->
 <context:component-scan base-package="cn.biz"></context:component-scan>
    <!-- 启动AOP注解 -->
     <aop:aspectj-autoproxy/>
 </beans>

spring-mybatis整合

整合的步骤

1. 导入相关的jar

  1. ​ mybatis

        <!--mybatis start-->
    <!--mysql  jar-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.17</version>
    </dependency>

    <!-- mybatis -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.2</version>
    </dependency>

    <!--log4j-->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
    <!--mybatis end-->

  2. spring

    <!--spring start-->
    <!-- spring-beans -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

    <!--spring-core -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

    <!-- spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

    <!-- spring-expression -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>5.1.9.RELEASE</version>
    </dependency>

    <!-- commons-logging -->
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.2</version>
    </dependency>

    <!--spring end-->

  3. 数据源

       <!-- commons-dbcp2 -->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-dbcp2</artifactId>
      <version>2.7.0</version>
    </dependency>

    <!-- commons-pool2 -->
    <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
      <version>2.7.0</version>
    </dependency>

  4. spring-mybatis

    <!--spring-mybatis end-->
<!-- mybatis-spring -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.1</version>
</dependency>
<!-- spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>
<!-- spring-tx -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>
<!--spring-mybatis end-->

2. 配置mybatis-config.xml文件

由于数据源的配置移入了spring中，所以mybatis-config.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>

    <settings>
        <setting name="logImpl" value="LOG4J"></setting>
    </settings>

    <typeAliases>
        <package name="cn.pojo"/>
    </typeAliases>
</configuration>

3. 配置spring-config.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: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">
	<!-- 内部配置数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url">
            <value><![CDATA[jdbc:mysql://127.0.0.1:3306/easybuy?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8]]></value>
        </property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    <!--定义工厂-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:myBatis-config.xml"/>
    </bean>

    <!-- 将mapper里的映射文件，全部通过工厂创建好bean 创建好的bean id命名就是类名首字母改成小写 -->
    <bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.mapper" />
    </bean>
    <!--单个单个类的扫描 -->
    <!--<bean id="classesMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="mapper.classes.ClassesMapper" />
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>-->
    <!-- 根据已存在的mappper的bean 定义biz层的bean -->
    <bean id="classesService" class="service.impl.ClassesServiceImpl">
       <property name="classesMapper" ref="classesMapper"></property>
    </bean>
</beans>

4. 测试

@Test
public  void testRole(){
    ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
    对象类型 对象名 = (对象类型)context.getBean("bean的id");
    对象名.方法();
}

事务

1. 导入jar

由于在配置spring-mybatis和aop的时候就已经将jar导入，这里就不用导入jar了

2. 配置声明式事务

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url">
            <value><![CDATA[jdbc:mysql://127.0.0.1:3306/easybuy?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8]]></value>
        </property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    
    <!--定义切面-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--设置事件的属性-->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
             <!--tx:method可以有多个 name是必须的 用于指定匹配的方法-->
            <tx:method name="add" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- 定义切面 -->
    <aop:config>
        <!--定义切点-->
        <aop:pointcut id="pointCut" expression="execution(* cn.biz..*.*(..))"/>
        <!--将事务增强-->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut"></aop:advisor>
    </aop:config>
</beans>

Propagation支持7种不同的传播机制：

REQUIRED：如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。

SUPPORTS： 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。

NOT_SUPPORTED：总是非事务地执行，并挂起任何存在的事务。

REQUIRESNEW：总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

MANDATORY：如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

NEVER：总是非事务地执行，如果存在一个活动事务，则抛出异常

NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中。如果没有活动事务，则按REQUIRED属性执行。

3. 通过注解定义事务

  1. ​ 配置文件

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="cn.biz,cn.aop,cn.controller"/>

    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url">
            <value><![CDATA[jdbc:mysql://127.0.0.1:3306/easybuy?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8]]></value>
        </property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!--定义切面-->
    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
	
    <!-- 启用事务注解 -->
    <tx:annotation-driven transaction-manager="txManager"/>
</beans>

  2. 使用事务注解

    	@Transactional(propagation = Propagation.REQUIRED)
    public Integer add(Order order, OrderDetail orderDetail) throws Exception {
        orderMapper.add(order);
        orderDetail.setOrderId(order.getId());
        return orderDetailMapper.add(orderDetail);
    }

    此方法就添加了事务增强

桅森
关注
专栏目录
Spring简单使用
is_Javaer的博客
09-27 601
Spring 是一种轻量级开发框架，旨在提高开发人员的开发效率以及系统的可维护性。 我们一般说 Spring 框架指的都是 Spring Framework，它是很多模块的集合，使用这些模块可以很方便地协助我们进行开发。 Spring Core： 基础,可以说 Spring 其他所有的功能都需要依赖于该类库。主要提供 IoC 依赖注入功能。 Spring Aspects ： 该模块为与AspectJ的集成提供支持。 Spring AOP ：提供了面向切面的编程实现。 Spring JDBC : Java数
简单实用spring MVC教程
11-22
通过这个简单的 Spring MVC 教程，你将能够构建起对 Spring MVC 的基础认识，并能开始创建自己的 Web 应用。继续深入学习，包括 AOP、事务管理、国际化、MVC 数据绑定等，你将能够驾驭更复杂的项目。
Spring Cloud Hystrix简单实用
lydms的博客
07-15 1544
Hystrix，英文意思是豪猪，全身是刺，刺是一种保护机制。Hystrix也是Netflflix公司的一款组件。Hystrix是什么?在分布式环境中，许多服务依赖项中的部分服务必然有概率出现失败。Hystrix是一个库，通过添加延迟和容错逻辑，来帮助你控制这些分布式服务之间的交互。Hystrix通过隔离服务之间的访问点阻止级联失败，通过提供回退选项来实现防止级联出错。提高了系统的整体弹性。与Ribbon并列，也几乎存在于每个Spring Cloud构建的微服务和基础设施中。
简单实用spring-cloud-starter-stream-kafka以及手动提交
ai_haibin的博客
09-02 3216
spring-cloud-starter-stream-kafka
spring定时器的简单实用
qq_44580165的博客
03-18 1206
1.在主启动类上添加EnableScheduling注解表示开启定时器 @SpringBootApplication @ComponentScan("com.mac") @MapperScan("com.mac.wikimac.mapper") @EnableScheduling public class WikiMacApplication { 2.在方法上写@Scheduled()两种方式执行 @Component public class TestJob { private static f
Spring RestTemplate简单实用介绍
Burnup_110的博客
10-10 108
直接上传送门，讲解很详细，走你RestTemplate https://blog.csdn.net/qq_38526573/article/details/90668738
SpringSecurity 简单使用
qq_43560701的博客
01-25 5077
SpringSecurity 简单使用 在 Web 开发中安全是不可忽视的问题（软件安全技术！），现在从 SpringSecurity 和 Shiro 两个框架来学习一下安全框架在 Web 应用中的使用。 Spring Security is a powerful and highly customizable authentication and access-control framework. It is the de-facto standard for securing Spring-based
全面解读Spring Cloud Zuul：从配置到优化的实战指南
热门推荐
张彦峰的博客
02-14 164万+
在微服务架构中，API网关作为核心组件之一，承担着请求路由、负载均衡、安全认证等重要功能。Spring Cloud Zuul作为一款功能强大的API网关解决方案，得到了广泛应用。本文将深入探讨Spring Cloud Zuul的各项功能，从基础配置到工作原理，再到多层负载和应用优化，全面解析其在实际应用中的最佳实践与实用技巧，为开发者提供一站式指导，助力其打造高性能、高可用的微服务架构。
Spring 定时任务简单实用
weixin_52576960的博客
12-11 66
Spring Task 定时任务 主要内容 定时任务概述 ​ 在项目中开发定时任务应该一种比较常见的需求，在 Java 中开发定时任务主要有三种解决方案：一是使用JDK 自带的 Timer，二是使用第三方组件 Quartz，三是使用 Spring Task。 ​ Timer 是 JDK 自带的定时任务工具,其简单易用，但是对于复杂的定时规则无法满足，在实际项目开发中也很少使用到。Quartz 功能强大，但是使用起来相对笨重。而 Spring Task 则具备前两者的优点（功能强大且简单易用），使用起来很简单
轻松上手：Spring环境搭建的实用指南
学而时习之，不亦说乎？温故而知新，可以为师矣！
12-28 860
想要顺利开展Spring框架的开发，首先需要搭建一个稳定而高效的开发环境。本文将为你提供一份详尽的指南，从零开始，逐步引导你完成Spring环境的搭建过程。我们将涵盖Java开发工具的选择、Spring框架的安装配置，以及常见开发工具的集成。无论你是初学者还是有经验的开发者，这篇文章都将成为你搭建Spring开发环境的得力助手，让你能够更轻松地投入到Spring项目的开发中。
Spring Cloud GateWay 路由转发规则介绍 简单实用
stateCelebrateking的专栏
04-06 1351
Spring在因Netflix开源流产事件后，在不断的更换Netflix相关的组件，比如：Eureka、Zuul、Feign、Ribbon等，Zuul的替代产品就是SpringCloud Gateway，这是Spring团队研发的网关组件，可以实现限流、安全认证、支持长连接等新特性。 Spring Cloud Gateway Spring Cloud Gateway是SpringCloud的全...
实用SPRING
12-26
### 实用Spring：深入浅出Spring 2.5至3.0 #### 一、Spring框架简介 Spring框架是一款开源的轻量级Java应用开发框架，由Rod Johnson于2004年创建并发布，旨在简化企业级应用程序的开发过程。Spring的核心特性包括...
使用Spring实现省市级联,非常简单实用
02-23
在Spring框架中实现省市级联（Province-City联动）是一种常见的功能需求，特别是在开发具有地域选择功能的Web应用时。省市级联允许用户先选择省份，然后根据所选省份动态加载对应的城市列表。这种功能提高了用户体验...
spring RMI 实用分享
08-07
在Spring框架中，使用RMI变得更加简单。Spring提供了RmiProxyFactoryBean，它能够动态地生成一个代理，这个代理可以透明地调用远程对象的方法。这样，开发人员无需关心底层的RMI细节，只需要像调用本地对象一样调用...
【SpringCloud】Spring Cloud 开发环境搭建与基础工程构建
Hsusan的博客
09-15 1786
Oracle从JDK9开始每半年发布⼀个新版本, 新版本发布后, ⽼版本就不再进⾏维护. 但是会有⼏个⻓期维护的版本.⽬前⻓期维护的版本有: JDK8, JDK11, JDK17, JDK21在 JDK版本的选择上，尽量选择⻓期维护的版本.为什么选择JDK17?
Spring Session
2401_84881237的博客
09-18 417
它把 servlet 容器实现的 httpSession 替换为 spring-session ，Session 信息存储在 Redis 或其它数据库中统一管理，解决了 session 共享的问题。Spring Session 是 Spring 家族中的一个子项目，Spring Session 提供了用于管理用户会话信息的 API 和实现。在 Web 项目开发中，Session 会话管理是一个很重要的部分，用于存储与记录用户的状态或相关的数据。
springboot每次都需要重设密码？明明在springboot的配置中设置了密码
最新发布
Mero技术博客
09-21 159
接着，修改redis的配置文件，找到redis的安装目录，找到相关的conf文件，找到#requirepass，打开redis-cli.exe，输入config get requirepass，查看当前的密码是什么？第二步：重启redis服务生效。第一步：查看当前的密码是什么？去掉# 修改密码。
SpringBoot中基于Mybatis-Plus多表联查（无xml，通过注解实现）
weixin_45653328的博客111
09-19 696
主要是第三个@Result，通过javaType=List.class，many=@Many来指定这个Result的属性（通过CourseMapper中的方法来查询这个list集合）注意：要写方法名的全名称，包名+类名+方法名。@Results注解：有个id属性，可以理解为定义了一个方法，可以通过id引用，引用方式：ResultMap（“”）。首先，外部查询出这个学生对象，在@Results注解内，表示返回的实际结果集，学生id，学生name，课程Course对象的list集合。下面我们就学生来解决。
Spring框架详解：文件上传实用教程
它只是简单地返回一个预设的`Map`，供开发者在开发过程中测试文件上传的处理过程。 使用Spring框架实现文件上传功能的关键在于理解`MultipartFile`的工作原理和如何处理文件流。这涉及到HTTP请求的解析、文件操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值