Spring知识点概述

最新推荐文章于 2022-06-27 21:54:35 发布
最新推荐文章于 2022-06-27 21:54:35 发布
阅读量209 收藏 1
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31994123/article/details/108554665
版权

IOC概念原理

  1. 控制反转：把对象和对象之间调用过程，交给Spring管理

  2. 使用ioc的目的为了降低耦合度

ioc的底层原理：

  1. xml解析，工厂模式，反射

ioc（BeanFactory接口）

  1. IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

  2. Spring提供IOC容器实现两种方式（两种接口）

    • BeanFactory:IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用

      • 加载配置文件时不会创建对象，在获取对象才去创建对象

    • ApplicationContext:BeanFactory接口的子接口，提供更强大的功能，一般由开发人员进行使用

      • 加载配置文件的时候就会把在配置文件对象进行创建。

    • ApplicationContext接口有实现类

IOC操作bean管理

  1. Bean管理值得是两个操作

  2. Spring创建对象

  3. Spring注入属性

Bean管理操作的两种方式

  1. 基于XML方式实现

  2. 基于注解方式实现

IOC操作Bean管理（XML)

  1. 基于xml方式创建对象

    1. 在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建

    2. bean标签有很多属性，介绍常用的属性

      1. id:唯一标识

      2. class:类全路径（包类路径）

    3. 创建对象的时候，属性也是执行无参构造法完成对象创建

  2. 基于xml方式注入属性

    1. DI:依赖注入，就是注入属性

  3. 第一种注入方式，使用set方式进行注入

    1. 创建类，定义属性和对应的set方法

    2. 在Spring配置文件配置对象创建，配置属性注入

      1.  <!--2 set 方法注入属性-->
 <bean id="book" class="com.atguigu.spring5.Book">
  <!--使用 property 完成属性注入
  name：类里面属性名称
  value：向属性注入的值
  -->
  <property name="bname" value="易筋经"></property>
  <property name="bauthor" value="达摩老祖"></property>
 </bean>

  4. 第二种注入方式：使用有参数构造进行注入

    1. 创建类，定义属性，创建有参数构造方法

      1.  /**
 * 使用有参数构造注入
 */
 public class Orders {
  //属性
  private String oname;
  private String address;
  //有参数构造
  public Orders(String oname,String address) {
  this.oname = oname;
  this.address = address;
  }
 }

      2. 在Spring配置文件中进行配置

        1.  <bean id="orders" class="com.atguigu.spring5.Orders">
  <constructor-arg name="oname" value="电脑"></constructor-arg>
  <constructor-arg name="address" value="China"></constructor-arg>
 </bean>

  5. p名称空间注入

    1. 使用p名称空间注入，可以简化基于xml配置方式

      • 第一步添加p名称空间在配置文件中

      • 第二步进行属性注入，在bean标签里进行操作

      •  <!--set方法及逆行属性注入-->
 <bean id= “book" class="类全名路径" p:name(属性)="值" p:age=（）/>

IOC操作Bean管理（xml注入其它类型属性）

  1. 字面量

    1. null值

    2.  <!--null 值-->
 <property name="address"> <null/></propert

    3. 属性值包含特殊符号

      1.  <!--属性值包含特殊符号
  1 把<>进行转义 &lt; &gt;
  2 把带特殊符号内容写到 CDATA
 -->
 ​
 <property name="address"> <value><![CDATA[<<南京>>]]></value></propert

      2. 注入属性-外部bean

        1. 创建两个类service和dao类

        2. 在service调用dao里面的方法

        3. 在Spring配置文件中进行配置

          •  public class UserService {
  //创建 UserDao 类型属性，生成 set 方法
  private UserDao userDao;
  public void setUserDao(UserDao userDao) {
  this.userDao = userDao;
  }
  public void add() {
  System.out.println("service add...............");
  userDao.update();
  }
 }
 <!--1 service 和 dao 对象创建-->
 <bean id="userService" class="com.atguigu.spring5.service.UserService">
  <!--注入 userDao 对象
  name 属性：类里面属性名称
  ref 属性：创建 userDao 对象 bean 标签 id 值
  -->
  <property name="userDao" ref="userDaoImpl"></property>
 </bean>
 <bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>

      3. 注入属性-内部bean

        1. 一对多关系：部门和员工

        2. 在实体类之间表示一对多的关系

        3. 在spring配置文件中进行配置

          1.  <bean id="emp" class="com.atguigu.spring5.bean.Emp">
  <!--设置两个普通属性-->
  <property name="ename" value="lucy"></property>
  <property name="gender" value="女"></property>
  <!--设置对象类型属性-->
  <property name="dept">
  <bean id="dept" class="com.atguigu.spring5.bean.Dept">
  <property name="dname" value="安保部"></property>
  </bean>
  </property>
 </bean>
 ​

        4. 注入属性-级联赋值

          1. 第一种写法

            • <!--级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
 <!--设置两个普通属性-->
 <property name="ename" value="lucy"></property>
 <property name="gender" value="女"></property>
 <!--级联赋值-->
 <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
 <property name="dname" value="财务部"></property>
</bean>

          2. 第二种写法

            • <!--级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp"> <!--设置两个普通属性-->
  <property name="ename" value="lucy"></property>
   <property name="gender" value="女"></property> <!--级联赋值-->
  <property name="dept" ref="dept"></property> <property name="dept.dname" value="技术部"></property></bean><bean id="dept" class="com.atguigu.spring5.bean.Dept"> <property name="dname" value="财务部"></property></bea

IOC操作管理（xml注入集合属性）

  1. 注入数组类型属性

  2. 注入list集合属性

  3. 注入map集合属性

    1. 创建，定义数组，list,map,set类型属性，生成对应set方法

    2. 在spring配置文件进行配置

      • <!--1 集合类型属性注入-->
<bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
 <!--数组类型属性注入-->
 <property name="courses">
 <array>
 <value>java 课程</value>
 <value>数据库课程</value>
 </array>
 </property>
 <!--list 类型属性注入-->
 <property name="list">
 <list>
  <value>张三</value> <value>小三</value> </list> </property> <!--map 类型属性注入-->
  <property name="maps"> <map> <entry key="JAVA" value="java"></entry> <entry key="PHP" value="php"></entry> </map> </property> <!--set 类型属性注入-->
  <property name="sets"> <set> <value>MySQL</value> <value>Redis</value> </set> </property></bea

  4. 在集合里面设置对象类型

    • <!--创建多个 course 对象--
<bean id="course1" class="com.atguigu.spring5.collectiontype.Course"> <property name="cname" value="Spring5 框架"></property></bean><bean id="course2" class="com.atguigu.spring5.collectiontype.Course"> <property name="cname" value="MyBatis 框架"></property></bean><!--注入 list 集合类型，值是对象-->
<property name="courseList"> <list> <ref bean="course1"></ref> <ref bean="course2"></ref> </list></propert

  5. 把集合注入部分提取出来

    1. 在spring配置文件中引入命名空间 util

    2. 使用util标签完成list集合注入提取

      1. <!--1 提取 list 集合类型属性注入-->
<util:list id="bookList"> <value>易筋经</value> <value>九阴真经</value> <value>九阳神功</value></util:list><!--2 提取 list 集合类型属性注入使用-->
<bean id="book" class="com.atguigu.spring5.collectiontype.Book"> <property name="list" ref="bookList"></property></bean>

IOC操作bean管理（FactoryBean)

  1. Spring 有两种类型bean,一种普通bean，另外一种工厂bean(FactoryBean)

  2. 普通bean:在配置文件中定义bean类型就是返回类型

  3. 工厂bean:在配置文件中定义bean类型可以和返回类型不一样

    1. 创建类：让这个类作为工厂bean，实现接口factorybean

    2. 实现接口里面的方法，在实现的方法中定义返回的bean类型

      • public class MyBean implements FactoryBean<Course> {
 //定义返回 bean
 @Override
 public Course getObject() throws Exception {
 Course course = new Course();
 course.setCname("abc");
 return course;
 }
 @Override
 public Class<?> getObjectType() {
 return null;
 }
 @Override
 public boolean isSingleton() {
 return false;
 }
}



<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean">
</bean>



@Test
public void test3() {
 ApplicationContext context =
 new ClassPathXmlApplicationContext("bean3.xml");
 Course course = context.getBean("myBean", Course.class);
 System.out.println(course);
}

    IOC操作bean管理（bean作用域）

    1. 在spring中，设置创建bean实例是单实例还是多实例

    2. 在spring里面，默认情况下，bean是单实例对象

    3. 如何设置单实例还是多实例

      1. 在spring配置文件bean标签里面有属性（scope)用于设置单例还是多实例

      2. scope属性值

        • singleton表示单实例对象

        • propotype,表示多实例对象

      3. singleton和propotype的区别

        1. singleton单实例，prototype多实例

        2. 设置scope值是singleton时候，加载配置文件时就会创建单实例对象

        3. 设置为prototype时，不是在加载spring配置文件时候创建对象，在调用getbean方法时创建多实例对象

IOC操作bean管理（bean生命周期）

  1. 生命周期

    1. 从对象创建到对象销毁的过程

  2. bean生命周期

    1. 通过构造器创建bean实例（无参数构造）

    2. 为bean的属性设置值和对其他bean引用（调用set方法）

    3. 调用bean初始化方法（休要及逆行配置初始化的方法）

    4. bean可以使用了（对象获取到了）

    5. 当容器关闭的时候，调用bean的销毁方法(需要及逆行配置销毁的方法)

  3. bean的后置处理器，bean生命周期有七步

    1. 通过构造器创建bean实例（无参数构造）

    2. 为bean的属性设置值核对其他bean引用（调用set方法）

    3. 把bean实例传递bean后置处理器的方法postprocessBeforeInitialization

    4. 调用bean的初始化的方法（需要进行配置初始化的方法）

    5. 把bean实例传递bean后置处理器的方法postProcessAfterInitialization

    6. bean可以使用了（对象获取到了）

    7. 当容器关闭的时候，调用bean的销毁方法(需要及逆行配置销毁的方法)

IOC操作Bean管理（xml自动装配）

  1. 什么是自动装配

    1. 根据指定装配规则（属性名称或者属性类型），spring自动将匹配的属性值进行注入

  2. 演示自动装配过程

    1. 根据属性名称自动注入

      1. <!--实现自动装配
 bean 标签属性 autowire，配置自动装配
 autowire 属性常用两个值：
 byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
 byType 根据属性类型注入
-->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
 <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

      2. 根据属性类型自动注入

        1. <!--实现自动装配
 bean 标签属性 autowire，配置自动装配
 autowire 属性常用两个值：
 byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
 byType 根据属性类型注入
-->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
 <!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

ioc操作bean管理（外部属性文件

  1. 直接配置数据库信息

    1. 配置德鲁伊连接池

    2. 引入德鲁伊连接池相关依赖jar包

      • <!--直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
 <property name="url" 
value="jdbc:mysql://localhost:3306/userDb"></property>
 <property name="username" value="root"></property>
 <property name="password" value="root"></property>
</bean>

  2. 引入外部属性文件配置数据库连接池

    1. 创建外部属性文件properties格式文件，写数据库信息

    2. 把外部properties属性文件引入到spring配置文件中

      1. 引入context命名空间

        1. ⚫ 在 spring 配置文件使用标签引入外部属性文件
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <property name="driverClassName" value="${prop.driverClass}"></property>
 <property name="url" value="${prop.url}"></property>
 <property name="username" value="${prop.userName}"></property>
 <property name="password" value="${prop.password}"></property>
</bean>

ioc操作bean管理（基于注解方式）

  1. 注解：

    1. 注解是代码的特殊标记，格式：@注解名称

    2. 使用注解，注解作用在类上面，方法上面，属性上面

    3. 使用注解目的，简化xml配置

  2. Spring针对Bean管理中创建对象提供注解

    1. @Component

    2. @Service

    3. @Controller

    4. @Repository

      • 以上四个注解的功能都是一样的，都可以用来创建bean实例

  3. 基于注解方式实现对象创建

    1. 引入依赖

    2. 开启组件扫描

      • <!--开启组件扫描
 1 如果扫描多个包，多个包使用逗号隔开
 2 扫描包上层目录
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>

    3. 创建类，在类上面添加创建对象注解

      • @Component(value = "userService") //<bean id="userService" class=".."/>
public class UserService {
 public void add() {
 System.out.println("service add.......");
 }
}

    4. 开启组件扫描细节配置

      • <!--示例 1
 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容
-->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false">
 <context:include-filter type="annotation" 
 
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
 下面配置扫描包所有内容
 context:exclude-filter： 设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.atguigu">
 <context:exclude-filter type="annotation" 
 
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

      •  

    5. 基于注解方式实现属性注入

      1. @Autowired:根据属性配型进行自动配置

        1. 把service和dao对象创建，在service和dao类添加创建对象注解

        2. 在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解

          1. @Service
public class UserService {
 //定义 dao 类型属性
 //不需要添加 set 方法
 //添加注入属性注解
 @Autowired 
 private UserDao userDao;
 public void add() {
 System.out.println("service add.......");
 userDao.add();
 }
}

      2. @Qualifier：根据名称进行注入

        1. 和@Autowired一起使用

          1. //定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

      3. @Resource:根据类型注入，可以根据名称注入

        • //@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

      4. @Value:注入普通配型属性

        • @Value(value = "abc")
private String name;

    6. 完全注解开发

      1. 创建配置类，代替xml文件

        • @Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.aspz"})
public class SpringConfig {
}

      2. 编写测试类

        • @Test
public void testService2() {
 //加载配置类
 ApplicationContext context
 = new AnnotationConfigApplicationContext(SpringConfig.class);
 UserService userService = context.getBean("userService", 
UserService.class);
 System.out.println(userService);
 userService.add();
}

        •  

Aop面向切面编程

Aop的底层原理

  1. Aop底层使用动态代理

    1. 有接口的时候使用JDK的动态代理

      • 创建接口实现得分代理对象，然后增强类方法

      • Proxy.newProxyIntance(ClassLoader loader,类<?>[] interfaces,InvocationHandler h), 返回指定代理类实例

参数：
1.类加载器
2.增强方法所在类，这个类实现的接口，支持多个接口
实现这个接口的invocationHandler，创建代理对象，写增强部分

    2. 有实现类的时候使用CGLIB

      • 创建当前类子类的代理对象

AOP的术语

  1. 连接点：类里面哪些方法可以被增强，就叫做连接点

  2. 切入点：实际真正被增强的方法叫做接入点。

  3. 通知：

    1. 实际增强的逻辑部分

    2. 类型

      1. 前置通知

      2. 后置通知

      3. 环绕通知

      4. 异常通知

      5. 最终通知

  4. 切面

    1. 动作

    2. 即把通知应用到切入点的过程

AOP的操作

spring一般基于AspectJ实现AOP操作
Aop操作
	1.基于xml配置文件实现
	2.基于注解方式实现

切入点表达式：

  1. 作用：知道对哪个类的哪个方法进行增强

  2. 语法结构：execution( [权限修饰符] [返回类型] [类全路径] [方法名称] ([参数列表]))

主备工作，Aspect注解

  • 创建类

  • 创建增强类（编写增强逻辑）

  • 进行通知的配置

    • 在spring配置文件中，开启注解扫描

    • 在类上标记@Component注解创建对象

    • 在增强类上再加@Aspect注解生成代理对象

    • 在spring配置文件中开启生成代理对象

      • aop:aspectj-autoproxy/

在增强类里的方法上配置不同类型的通知,可以使用切入点表达式进行配置（excution)

  1. @Before(value="execution (* com.spz.dao.user.add(..))")
public void before(){
	sout("nihao  ")
}

@Before：前置通知
@After:后置通知
@Around:环绕通知，在方法前和方法后后进行通知，有一个参数ProceedingJoinPoint参数，调用该类的proceed方法即可/
    。
@AfterThrowing：异常通知，抛出异常会进行通知

相同的切入点抽取

  • 在增强类的增强方法上添加pointcut注解，value("待增强类的切入点表达式")

  • 然后在具体的增强类方法内@Before（value="相同切入点的方名"）

  • //相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.aopanno.User.add(..))")
public void pointdemo() {
}
//前置通知
//@Before 注解表示作为前置通知
@Before(value = "pointdemo()")
public void before() {
 System.out.println("before.........");
}

  • 多个增强类对同一个方法进行增强，设置增强方法的优先级

    • 使用order注解添加数字，数字越小优先级越高

    • @Component
@Aspect
@Order(1)
public class PersonPro

使用完全注解开发

  • 创建配置类，不需要创建配置文件

    • @Configuration
@ComponentScan(basePackages = {"com.atguigu"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop{
}

AOP操作（AspectJ配置文件）

  1. 创建两个类，增强类和被增强类，创建方法

  2. 在spring方法中创建两个类对象

    • <!--创建对象-->
<bean id="book" class="com.atguigu.spring5.aopxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.aopxml.BookProxy"></bean>

  3. 在spring中创建切入点

    • <!--配置 aop 增强-->
<aop:config>
 <!--切入点-->
 <aop:pointcut id="p" expression="execution(* 
com.atguigu.spring5.aopxml.Book.buy(..))"/>
 <!--配置切面-->
 <aop:aspect ref="bookProxy">
 <!--增强作用在具体的方法上-->
 <aop:before method="before" pointcut-ref="p"/>
 </aop:aspect>
</aop:config>

JDBCTemplate(概念和准备)

引入jar包

在spring配置文件中配置数据库连接池

  • <!-- 数据库连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" 
  destroy-method="close"> <property name="url" value="jdbc:mysql:///user_db" /> <property name="username" value="root" /> <property name="password" value="root" /> <property name="driverClassName" value="com.mysql.jdbc.Driver" /></bea

配置JDBCTemplate对象，注入Datasource对象

  • <!JdbcTemplate 对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <!--注入 dataSource-->
  <property name="dataSource" ref="dataSource"></property></bean>

创建service，dao类，在dao注入jdbctemplate对象配置文件

<!-- 组件扫描 -->
<context:component-scan base-package="com.atguigu"></context:component-scan>
⚫ Service
@Service
public class BookService {
 //注入 dao
 @Autowired
 private BookDao bookDao;
}


⚫ Dao@Repositorypublic class BookDaoImpl implements BookDao { //注入 JdbcTemplate
  @Autowired private JdbcTemplate jdbcTemplate

JdbcTemplate操作数据库

事务操作

事务概念

事务是数据库操作的基本单元，逻辑上一组操作，要么都成功，要么有一个失败所有的操作都失败
事物的四个特性（ACID)
	原子性
	一致性
	隔离性
	持久性

事务操作 （搭建事务操作环境）

  1. 创建数据库表，添加记录

  2. 创建service，搭建dao，完成对象创建和注入关系

    • service注入dao，在dao注入jdbctemplate，在jdbcTemplate注入DataSource

      • @Service
public class UserService {
 //注入 dao
 @Autowired
 private UserDao userDao;
}
@Repository
public class UserDaoImpl implements UserDao {
 @Autowired
  private JdbcTemplate jdbcTemplate;
  }

  3. 在dao创建两个方法，在service创建方法（转账方法）

    • @Repository
public class UserDaoImpl implements UserDao {
 @Autowired
 private JdbcTemplate jdbcTemplate;
 //lucy 转账 100 给 mary
 //少钱
 @Override
 public void reduceMoney() {
 String sql = "update t_account set money=money-? where username=?";
 jdbcTemplate.update(sql,100,"lucy");
 }
 //多钱
 @Override
 public void addMoney() {
 String sql = "update t_account set money=money+? where username=?";
 jdbcTemplate.update(sql,100,"mary");
 }
}
@Service
public class UserService {
 //注入 dao
 @Autowired
 private UserDao userDao;
 //转账的方法
 public void accountMoney() {
 //lucy 少 100
 userDao.reduceMoney();
 //mary 多 100
 userDao.addMoney();
 }
}

事务操作（spring事务管理介绍）

  1. 事务添加到JavaEE三层架构的service（业务逻辑层）

  2. 在Spring进行事务管理操作

    • 有两种方式：编程式事务管理和声明式事务管理（使用）

  3. 声明式事务管理

    1. 基于注解方式（使用）

    2. 基于xml配置文件方式

  4. 在Spring进行声明式事务管理，底层使用AOP原理

  5. Spring事务管理API

    • 提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

    •  

事务操作（注解声明式事务管理）

  1. 在spring配置文件中配置事务管理

    1. <!--创建事务管理器-->
bean id="transactionManager" 
lass="org.springframework.jdbc.datasource.DataSourceTransactionManager"><!--注入数据源-->
  <property name="dataSource" ref="dataSource"></property>/bea

       

  2. 在spring配置文件中开启事务注解

    • （1）在 spring 配置文件引入名称空间 tx<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" 
  xmlns:aop="http://www.springframework.org/schema/aop" 
  xmlns:tx="http://www.springframework.org/schema/tx" 
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans.xsd 
  http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context.xsd 
  http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop.xsd
 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">（2）开启事务注解<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

    •  

  3. 在service类上或者service类里面方法上面添加事务注解

    • @Transactional,这个注解添加到类上面，也可以添加方法上面

    • 如果把这个注解添加类上面，这个类里面所有的方法都添加事务

    • 如果把注解添加到方法上面，这个方法添加事务

     

    事务操作（声明式事务管理参数配置）

    1. 在service类上面添加注解@Transactional,在这个注解里面可以配置事务相关的参数。

    2. propagation:事务传播行为

      1. 多事务方法直接进行调用，这个过程中事务是如何进行管理的事务传播行为

        1. 事务方法：对数据库数据进行变化的操作，

          1. @Transactional
public void add(){
	//掉哦用update方法
	update();
}

          2. spring框架事务传播行为有7种

            1. REQURED:如果add方法本身有事务，调用update方法之后，update使用当前add方法里面事务，如果add方法本身没有事务，就创建新事务

            2. REQURED_NEW:使用add方法调用update方法，如果add方法无论是否有事务，都创建新的事务。

            3.  

          3. ioslation:事务隔离级别

            1. 事务有特性成为隔离性，多事务操作之间不会产生影响，不考虑隔离性产生很多问题。

            2. 有三个读问题，脏读，不可重复读，虚读

            3. 脏读：一个未提交的事务读取到另一个未提交的事务的数据

            4. 不可重复读：一个未提交的事务读取到空一个已提交的事务修改数据

            5. 虚读：一个未提交的事务读取到另一个提交事务添加数据

            6. 通过事务隔离级别，解决读问题

               

          4. timeout:超时时间

          5. readonly:是否只读

          6. rollbackFor:回滚：设置出现异常进行回滚

          事务操作（XML声明式事务管理）

          1. 在Spring配置文件中进行配置

            1. 配置事务管理器

            2. 配置通知

            3. 配置切入点和切面

              1. <!--1 创建事务管理器-->
<bean id="transactionManager" 
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <!--注入数据源-->
 <property name="dataSource" ref="dataSource"></property>
</bean>
<!--2 配置通知-->
<tx:advice id="txadvice">
 <!--配置事务参数-->
 <tx:attributes>
 <!--指定哪种规则的方法上面添加事务-->
 <tx:method name="accountMoney" propagation="REQUIRED"/>
 <!--<tx:method name="account*"/>-->
 </tx:attributes>
</tx:advice>
<!--3 配置切入点和切面-->
<aop:config>
 <!--配置切入点-->
 <aop:pointcut id="pt" expression="execution(* 
com.atguigu.spring5.service.UserService.*(..))"/>
 <!--配置切面-->
 <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

            事务操作（完全注解声明式事务管理）

            1. 创建配置类，使用配置类代替xml文件

              1. @Configuration //配置类
@ComponentScan(basePackages = "com.atguigu") //组件扫描
@EnableTransactionManagement //开启事务
public class TxConfig {
 //创建数据库连接池
 @Bean
 public DruidDataSource getDruidDataSource() {
 DruidDataSource dataSource = new DruidDataSource();
 dataSource.setDriverClassName("com.mysql.jdbc.Driver");
 dataSource.setUrl("jdbc:mysql:///user_db");
 dataSource.setUsername("root");
 dataSource.setPassword("root");
 return dataSource;
 }
 //创建 JdbcTemplate 对象
 @Bean
 public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
 //到 ioc 容器中根据类型找到 dataSource
 JdbcTemplate jdbcTemplate = new JdbcTemplate();
 //注入 dataSource
 jdbcTemplate.setDataSource(dataSource);
 return jdbcTemplate;
 }
 //创建事务管理器
 @Bean
 public DataSourceTransactionManager 
getDataSourceTransactionManager(DataSource dataSource) {
 DataSourceTransactionManager transactionManager = new 
DataSourceTransactionManager();
 transactionManager.setDataSource(dataSource);
 return transactionManager;
 }
}
Pricate_king
关注
Spring框架知识点
xh_yj的博客
01-12 941
一、Spring框架概述 1、Spring是轻量级的开源JavaEE框架 2、Spring可以解决企业应用开发的复杂性 3、Spring有两个核心部分：IOC和Aop   (1)IOC:控制反转，把创建对象过程交给Spring进行管理   (2)Aop:面向切面，不修改源代码进行功能增强 4、Spring的特点   (1):方便解耦，简化开发。   (2):Aop编程支持   (3):方便程序测试   (4):方便和其他框架进行整合   (5):方便进行事务操作   (6):降低API开发难度 ...
Spring知识点讲解（建议英语听力好的下载）
02-02
根据提供的信息，我们可以深入探讨与“Spring框架”相关的知识点。虽然描述部分并未提供具体的信息，但从标题中可以明确看出这是关于Spring框架的知识讲解。接下来，我们将详细介绍Spring框架的基础概念、核心特性...
Spring5.zip
08-02
Spring运行helloworld所需的三个基础包，分明为com.springsource.org.apache.commons.logging-1.1.1.jar，spring-beans-5.0.2.RELEASE.jar,spring-core-5.0.2.RELEASE.jar
Spring框架
璃尔 ° 的博客
09-18 2197
JavaWeb一、Spring概述二、Spring快速入门三、Spring配置文件四、Spring配置数据源五、Spring注解开发六、Spring的AOP简介七、基于XML的AOP开发八、基于注解的AOP开发 一、Spring概述 二、Spring快速入门 三、Spring配置文件 四、Spring配置数据源 五、Spring注解开发 六、Spring的AOP简介 七、基于XML的AOP开发 八、基于注解的AOP开发 每日一点点进步 不进则退 ......
Spring5 框架
qq_43669047的博客
05-03 1155
包含Spring5概述、IOC、AOP、JDBCTemplate等内容
Spring5框架
m0_56782929的博客
04-24 525
文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 一、Spring5框架的概述 1、 Spring 是一种轻量级的开源的JavaEE框架 2、 Spring 开源解决企业应用开发的复杂性，就是使企业开发变得更加简便 3、 Spring有两个核心的部分：IOC和AOP 1）IOC（Inversion of control）：控制反转，把创建对象的任务交给Spring进行管理 2） AOP（A...
Spring核心知识点
最新发布
04-06
以上就是Spring框架的核心知识点概述，通过这些模块的支持，Spring框架成为了企业级Java开发中最受欢迎的框架之一。开发者可以根据实际项目需求选择合适的功能模块进行集成，以提高开发效率和系统的可维护性。
spring知识点总结
06-25
这样的总结对于快速回顾和记忆Spring知识点非常有用。 **学习路径** 对于初学者，首先应该理解Spring的基本概念，如IoC和AOP，然后逐步学习Spring的各个模块，例如Spring MVC（用于构建Web应用）、Spring JDBC和...
Spring Boot技术知识点：如何深入理解@Component注解
06-18
1. **`@Component`概述** `@Component`是Spring框架提供的一个注解，用于标记一个Java类为Spring容器管理的bean。当Spring扫描到标记了`@Component`的类时，会自动将其实例化并添加到bean定义中。这样，我们就可以...
Spring5框架（一）
遗落在树梢的风筝
04-30 175
基本概念 Spring是轻量级、开源的Java EE框架 Spring有两个核心部分：IOC和AOP （1）IOC：inversion of control，控制反转，把创建对象过程交给Spring进行管理 （2）AOP：aspect of plane,面向切面，不修改源码进行功能增强 下载Spring地址:https://repo.spring.io/release/org/springframework/spring/ 在IDEA中导入Spring的依赖jar包 新建一个Spring的工程 在工程
Spring5框架介绍
jl935418600的博客
06-02 327
Spring5框架介绍 1.背景 1.1引例 public class AccountServiceImpl implements IAccountService { private IAccountDao accountDao = new AccountDaoImpl(); } 上面的代码表示： 业务层调用持久层，并且此时业务层在依赖持久层的接口和实现类。如果此时没有持久层实现类，编译将不能通...
spring5
Raccoon的博客
08-14 261
① What is spring？ 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低 API 开发难度 ② IOC 1.I
一、Spring 框架概述
Yes_water的博客
04-26 312
Spring 框架概述 Spring 入门案例
一、Spring5框架概述
weixin_46649015的博客
02-11 140
1. Spring5框架概述 1.1. Spring5 是轻量级的javaEE框架 主要目的：解耦合 方式：工厂模式 + 反射 1.2. Spring 可以解决企业应用开发的复杂性 1.3. Spring 两个核心部分：IOC 和 Aop IOC控制反转：把创建对象的过程交给Spring进行管理 Aop面向切面：不修改源代码进行功能增强 1.4. Spring 特点： 方便解耦，简化开发 Aop编程支持 方便程序测试（Test测试单元） 方便和其他框架进行整合 Spring MVC、MyBati
Spring5框架 详解
Sayonara_LM的博客
06-10 261
Spring框架概述IOC接口（BeanFactory）IOC操作Bean管理（基于XML）IOC操作Bean管理（FactoryBean）IOC操作Bean管理（bean作用域）IOC操作bean管理（bean生命周期）IOC操作bean管理（xml自动装配） IOC操作bean管理（外部属性文件） 基于注解方式实现属性注入完全注解开发 AOP（概念）AOP（底层原理）AOP（JDK动态代理）编写JDK动态代理代码 ①创建接口，定义方法 ②创建接口实现类，实现方法 ③使用Proxy类创建接口代理对象
Spring5 框架——（一）简介
weixin_44005940的博客
06-27 390
Spring框架教程，Spring简介，Spring 5
Spring框架入门与核心知识点详解
1. **Spring框架概述** - Spring框架由Rod Johnson于2003年创建，其设计哲学基于轮子理论，鼓励开发者利用现有的成熟技术，而不是从头开始编写。 - 春风的核心宗旨在于提供一种简单的方式来集成各种企业级功能，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值