Spring学习（详细）

Spring 概念

1. spring是开源的轻量级框架

轻量级：框架使用不需要依赖其他技术。可独立使用。

2. Spring是一站式框架

（1） Spring在javaEE三层结构中，每一层都提供了不同的解决技术，则称为一站式。

--web层：springMVC

--service层：spring的IOC

--dao层：spring的JdbcTemplate

3. Spring核心主要两部分：

（1）aop：面向切面编程

--扩展功能不是修改源代码实现。

（2）Ioc：控制反转

--比如有一个User类，在类中有方法add();（不是静态方法），通常我们调用里面的方法需要创建类对象，需要new关键字来创建。

例：

User user= new User();

user.add();

--ioc创建对象不需要通过上述方式实现，而是交给spring配置创建类对象。

4. spring版本

Spring4.x

Spring核心：IOC

1. 控制反转（IOC）就是吧创建对象交给spring容器进行管理。

2. IOC操作两部分：

（1）：IOC的配置文件方式

（2）：IOC的注解方式

Ioc底层原理

1. ioc底层原理实用技术

（1）xml配置文件

（2）dom4j解析xml

（3）工厂设计模式

（4）反射机制

2.画图分析IOC实现原理

（1）使用工厂模式解耦操作，发现依然存在耦合

spring总结

降低类与类之间的耦合度！！！

当你类路径发生变化时，只需要修改配置文件，其余不需要修改。

IOC入门案例

第一步：导入jar包

（1）解压资料zip文件

spring总结

解压后Jar包特点：

分别是：jar包文档源码

spring总结

最基本共能只需要这些核心jar包：

spring总结

（2）导入日志jar包

spring总结

（3）共需jar包：

spring总结

第二步：创建类对象，在类里创建方法

（1）最原始做法

public class User79 {

public void add(){

System.out.println("杭州矩衡科技！");

}

public static void main(String[] args) {

//最原始做法

User79user79 = new User79();

user79.add();

}

第三步：创建spring配置文件，配置创建类

（1）spring核心配置文件名称和位置不是固定的

----建议放在src下面，官方建议名称：applicationContext.xml

（2）引入schema约束

<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 http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

（3）配置对象创建

spring总结

第四步：写测试类

@Test

public void testUser79(){

//加载spring配置文件，根据创建对象

ApplicationContext context=

new ClassPathXmlApplicationContext("applicationContext.xml");

//得到配置创建对象

User79 user79 = (User79) context.getBean("user79");

System.out.println(user79);

user79.add();

Spring的bean管理（xml配置文件）

bean实例化的三种方式

1. 概念：所谓bean实例化就是在spring里面通过配置文件创建对象

2. Bean实例化三种方式：

第一种：使用类的无参构造创建

上一个IOC入门案例用的就是这种方式。

spring总结

注：图片中意思是：类中没有有参构造时，无参构造是默认不写的，但是真实存在，当加上一个有参构造时，无参构造就必须声明。

第二种：使用静态工厂创建

（1）创建静态方法，返回类对象

public class Bean01 {

public void add(){

System.out.println("Bean01....");

}

public class Bean01Factory {

//静态方法，返回bean01对象

public static Bean01 getBean01(){

return new Bean01();

}

静态工厂，其中的getBean01方法可以通过Bean01Factory类名直接调用

第三种：使用实例工厂创建

（1）创建的不是静态方法，返回类对象

public class Bean02 {

public void add(){

System.out.println("Bean02....");

}

public class Bean02Factory {

//fei静态方法，返回bean02对象

public Bean02 getBean02(){

return new Bean02();

}

public class TestIoc {

@Test

public void testUser79(){

//加载spring配置文件，根据创建对象

ApplicationContext context=

new ClassPathXmlApplicationContext("applicationContext.xml");

//得到配置创建对象

Bean02 bean02 = (Bean02) context.getBean("Bean02");

System.out.println(bean02);

}

Bean标签的常用属性

（1）id属性：id表示起的名字，可以任意命名。

-----id属性值，不能包含特殊符号，_ ，$ ，#等

-----代码中根据id值得到配置的对象。

（2）class属性：创建对象所在类的全路径

（3）name属性：功能和id属性一样，只是可以加入特殊符号，现在已经不用了，这是遗留问题，比如struts1里面有很多action写法可以写一些符号，name是整合他们而用到的属性，struts2中没有

（4）scope属性：（了解）

spring总结

属性注入

1. 创建对象时，向类里面属性里面设置值

2. 属性注入的方式（三种方式）

（1）set注入

（2）有参构造注入

（3）接口注入

3. 在spring框架之内，支持前两种方法

（1）set方法

（2）有参构造

使用有参构造注入属性

<constructor-arg name="username" value="小王小马"></constructor-arg>

</bean>

public class Property01 {

private String username;

public Property01(String username) {

this.username = username;

}

public void test01(){

System.out.println("demo01...."+username);

}

public class TestIoc {

@Test

public void testUser79(){

//加载spring配置文件，根据创建对象

ApplicationContext context=

new ClassPathXmlApplicationContext("applicationContext.xml");

//得到配置创建对象

Property01 property01 = (Property01) context.getBean("demo");

System.out.println(property01);

property01.test01();

}

使用set方法注入属性

<!-- 注入值设置

name属性值：类里面定义的属性名称

value 设置具体值

-->

</bean>

public class Book {

private String bookname;

public void setBookname(String bookname) {

this.bookname = bookname;

}

public void demobook(){

System.out.println("book："+bookname);

}

public class TestIoc {

@Test

public void testUser79(){

//加载spring配置文件，根据创建对象

ApplicationContext context=

new ClassPathXmlApplicationContext("applicationContext.xml");

//得到配置创建对象

Book book = (Book) context.getBean("book");

System.out.println(book);

book.demobook();

}

注入对象类型的属性

1. 创建service类和dao类

（1）在service得到dao对象

2. 具体实现过程

（1）生成UserDao的set方法

public class UserDao {

public void add(){

System.out.println("userDao..........");

}

public class UserService {

//1定义Dao类型属性

private UserDao userDao;

//生成set方法

public void setUserDao(UserDao userDao) {

this.userDao = userDao;

}

public void add(){

System.out.println("Service..........");

//在Service里面得到Dao的是对象才能调用Dao的方法(原始做法)

//UserDao dao = new UserDao();

//dao.add();

userDao.add();

}

public class TestIoc {

@Test

public void testUser79(){

//加载spring配置文件，根据创建对象

ApplicationContext context=

new ClassPathXmlApplicationContext("applicationContext.xml");

//得到配置创建对象

UserService userService= (UserService) context.getBean("userService");

userService.add();

}

<!-- 注入dao对象 name属性：写的是service类里面属性的名称

现在不能写value属性了，因为之前是字符串，现在是对象

写ref属性：dao配置bean标签中id值 -->

</bean>

P名称空间注入

同一个标签中不能有相同的属性，所以引入命名空间

第一步：建立P命名空间引用

引入后才能操作

public class TestIoc {

@Test

public void testUser79(){

//加载spring配置文件，根据创建对象

ApplicationContext context=

new ClassPathXmlApplicationContext("applicationContext.xml");

//得到配置创建对象

Person person = (Person) context.getBean("person");

person.test1();

}

复杂类型属性注入

1. 数组

2. List集合

3. Map集合

4. Properties

都将他们定义在Person类中：

private String[] arrs;

private List<String> list;

private Map<String,String> map;

private Properties properties;

public void setArrs(String[] arrs) {

this.arrs = arrs;

}

public void setList(List<String> list) {

this.list = list;

}

public void setMap(Map<String, String> map) {

this.map = map;

}

public void setProperties(Properties properties) {

this.properties = properties;

}

public void test1(){

System.out.println("arrs"+Arrays.deepToString(arrs));

System.out.println("list"+list);

System.out.println("map"+map);

System.out.println("properties"+properties);

}

<list>

</list>

</property>

<list>

</list>

</property>

<map>

</map>

</property>

<props>

<prop key="driverclass">com.mysql.jdbc.Driver</prop>

</props>

</property>

</bean>

IOC和DI区别

（1）IOC控制反转，把对象创建交给spring进行配置

（2）DI依赖注入，创建对象过程中，向类里面的属性中设置值。

（3）两者之间关系：依赖注入不能单独存在，需要在IOC的基础之上完成操作。

Spring的bean管理（注解）

注解

1. 代码里面的特殊的标记，使用注解可以完成功能

2. 注解写法@注解名称（属性名称=属性值）

3. 可以使用在类上面方法上面属性上面

Spring注解开发准备

1. 导入jar包

（1）导入基本的jar包

spring总结

（2）导入aop的jar包

spring总结

2. 创建类，创建方法

3. 创建spring配置文件，引入约束

spring总结

注解创建对象

1. 在创建对象的类上面使用注解实现

@Component(value="user")//<bean id = "user" class=""/>

@Scope(value="prototype")//多实例

public class User {

public void add(){

System.out.println("anno.....");

}

创建对象有四个注解：

[email protected]

[email protected] web层

[email protected] 业务层

[email protected] 持久层

目前这四个注解功能都是一样的，都创建对象

3.创建对象是单实例还是多实例

@Scope

配置内容，开启注解扫描

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

注解注入属性

1. 创建service类，创建dao类，在service得到dao对象

（1）创建dao和service对象，在service类里面定义dao类型属性

@Component(value="userDao")

public class UserDao {

public void add(){

System.out.println("userDao....");

}

@Component(value="userService")

public class UserService {

//创建Dao对象

//在Dao属性上使用@Autowired第一种

//@Autowired

//private UserDao userDao;

//使用注解方式不需要set方法

@Resource(name="userDao")//第二种

private UserDao userDao;

public void add(){

System.out.println("service......");

userDao.add();

}

无需配置，只要开启扫描即可

配置文件和注解混合使用

1. 创建对象操作使用配置文件方式实现

public class BookDao {

public void book(){

System.out.println("bookDao....");

}

public class OrderDao {

public void buy(){

System.out.println("orderDao..........");

}

public class BookService {

//得到bookDao和orderDao

@Resource(name="bookDao")

private BookDao bookDao;

@Resource(name="orderDao")

private OrderDao orderDao;

public void add(){

System.out.println("service........");

bookDao.book();

orderDao.buy();

}

配置文件创建对象

2. 注入属性操作使用注解方式实现（要开启注解扫描的配置）

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

自我拓展全配置文件实现上述操作

配置文件内容

</bean>

</beans>

代码内容

public class BookDao {

public void book(){

System.out.println("bookDao....");

}

public class OrderDao {

public void buy(){

System.out.println("orderDao..........");

}

package com.game79.xmlanno;

public class BookService {

//得到bookDao和orderDao

private BookDao bookDao;

private OrderDao orderDao;

public void setBookDao(BookDao bookDao) {

this.bookDao = bookDao;

}

public void setOrderDao(OrderDao orderDao) {

this.orderDao = orderDao;

}

public void add(){

System.out.println("service........");

bookDao.book();

orderDao.buy();

}

Spring核心：AOP

Aop相关概念

1. aop：面向切面编程（面向方面），扩展功能不修改源代码实现

spring总结

AOP原理

1. 画图分析

（1）纵向演变

spring总结

（2）横向演变

spring总结

Aop操作相关术语

joinpoint（连接点）：类里哪些方法可以被增强，就被称为连接点。（delete，add，等）

pointcut（切入点）：类里有很多方法被增强，比如在实际操作中，只增强了类中的add和update方法，实际增强的方法就是切入点（通俗点：通过切入的表达式筛选需要切入的业务方法）

advice（通知/增强）：增强的逻辑，称为增强。比如拓展一个日志共功能，这个日志功能成为增强；

spring总结

如果add()方法为例：

在方法之前执行

在方法之后执行

方法执行异常

在后置之后

在方法之前和之后来执行称为环绕

Aspect（切面）：把我们的增强应用到具体的方法上面，过程称为切面

（把增强应用到切入点的过程）

spring总结

springAOP操作

1. 使用Aspectj实现aop操作

spring总结

（1）本身不是spring的一部分，和spring一起使用，进行aop操作。

2. 使用aspectj实现aop有两种方式

（1）基于aspectj的xml配置

（2）基于aspect的注解方式

Aop操作准备

1. jar包

spring总结

AOP功能是增强类中的方法（某个或者某些）

2. 引入约束

<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">

AOP增强配置方式

1. Book类

public class Book {

public void add(){

System.out.println("add。.........");

}

2. StrongBook类

import org.aspectj.lang.ProceedingJoinPoint;

public class StrongBook {

public void beforeAdvice(){

System.out.println("前值增强.........");

}

public void after1(){

System.out.println("在Add()之后执行后置增强........");

}

//环绕通知

public void arround1(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{

//方法之前执行

System.out.println("方法之前输出......");

//执行被增强的方法

proceedingJoinPoint.proceed();

//方法之后执行

System.out.println("方法之后输出......");

}

第一步：

使用表达式配置切入点（实际增强的方法）指定切入点

表达式格式：

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

（1） execution(* com.game79.aop.Book.add(..))

spring总结

（2） execution(* com.game79.aop.Book.*(..))

（3）execution(* *.*(..))

增强配置

<aop:config>

<aop:pointcut expression="execution(* com.game79.aop.Book.*(..))" id="pointcut1"/>

<!-- 2.配置切面

把增强用到方法上面

-->

<aop:aspect ref="strongBook">

<!-- 1.前置通知

配置增强类型

method：增强类里面使用哪个方法作为前置增强

pointcut-ref:增强用在哪个切入点上

-->

<aop:before method="beforeAdvice" pointcut-ref="pointcut1"/>

<aop:after method="after1" pointcut-ref="pointcut1"/>

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

</aop:aspect>

</aop:config>

最终执行结果：

spring总结

log4j

1.通过log4j可以看到程序运行过程中更详细的信息。（哪些对象创建了，加载了哪些配置文件）

(1) 经常使用log4j查看日志

(2) 复制log4j的jar包

AOP增强注解方式

1. 创建类

public class Book {

public void add(){

System.out.println("book......");

}

@Aspect

public class StrongBook {

//在方法上面注解完成增强配置

@Before(value="execution(* com.game79.aop.Book.*(..))")

public void before1(){

System.out.println("方法前.........");

}

2.配置文件

配置创建类对象，注解实现aop

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

spring总结

Spring的jdbcTemplate操作（jdbc模板操作）

1.spring框架一站式框架

（1）针对三层，每一层都有解决技术

（2）在dao层使用jdbcTemplate

2.spring对不同的持久化技术都进行了封装

spring总结

jdbcTemplate对jdbc进行封装

3..jdbcTemplate使用和jdbcUtils使用相似，都对数据库进行封装

增加

1. 导入jdbcTemplate相关jar包

spring总结

导入驱动jar包

spring总结

2.创建对象，设置数据库信息

3.创建jdbcTemplate对象，设置数据源

3. 调用jdbcTemplate对象里的方法实现操作

//1.添加操作

@Test

public void add(){

//.创建对象，设置数据库信息

DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8");

dataSource.setUsername("root");

dataSource.setPassword("root");

//.创建jdbcTemplate对象，设置数据源

JdbcTemplate jdbcTemplate =new JdbcTemplate(dataSource);

//.调用jdbcTemplate对象离得方法实现操作

//创建sql语句

String sql="insert into user values(?,?)";

int rows=jdbcTemplate.update(sql, "lucy","250");

System.out.println(rows);

}

注意报错信息：

spring总结

删除

@Test

public void delete(){

//.创建对象，设置数据库信息

DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8");

dataSource.setUsername("root");

dataSource.setPassword("root");

//.创建jdbcTemplate对象，设置数据源

JdbcTemplate jdbcTemplate =new JdbcTemplate(dataSource);

//调用update方法实现删除

String sql="delete from user where username=?";

int rows=jdbcTemplate.update(sql,"lucy");

System.out.println(rows);

}

修改

@Test

public void update(){

//.创建对象，设置数据库信息

DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8");

dataSource.setUsername("root");

dataSource.setPassword("root");

//.创建jdbcTemplate对象，设置数据源

JdbcTemplate jdbcTemplate =new JdbcTemplate(dataSource);

//调用update方法

String sql="update user set password=? where username=?";

int rows=jdbcTemplate.update(sql,"1314","lucy");

System.out.println(rows);

}

查询

1. 使用jdbcTemplate实现查询操作，跟dbUtils相似，但也有不一样的地方

spring总结

不同的返回结果，有不同的实现类，比如BeanHandler

spring总结

2. 查询具体实现

第一：查询返回某一个值

第二：查询返回对象

第三查询返回list集合

spring总结

（1）第一个参数是sql语句

（2）第二个参数是返回值类型的class

public class JdbcTemplateDemo2 {

//1.查询返回某个值

@Test

public void testcount(){

//.创建对象，设置数据库信息

DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8");

dataSource.setUsername("root");

dataSource.setPassword("root");

//.创建jdbcTemplate对象，设置数据源

JdbcTemplate jdbcTemplate =new JdbcTemplate(dataSource);

//.调用方法得到记录数

String sql="select count(*)from user";

//调用jdbcTemplate的方法

int count =jdbcTemplate.queryForObject(sql, Integer.class);

System.out.println(count);

}

//2.jdbc实现代码

@Test

public void TestJdbc(){

Connection conn = null;

PreparedStatement psmt = null;

ResultSet rs= null;

try {

//加载驱动

Class.forName("com.mysql.jdbc.Driver");

//创建链接

conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8","root","root");

//编写sql语句

String sql= "select * from user where username=?";

//预编译sql

psmt=conn.prepareStatement(sql);

//设置参数的值

psmt.setString(1, "lucy");

//执行sql

rs = psmt.executeQuery();

//遍历结果集

while(rs.next()){

//得到返回的结果

String username = rs.getString("username");

String password = rs.getString("password");

//放到user对象中去

User user = new User();

user.setUsername(username);

user.setPassword(password);

System.out.println(user);

}

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}finally{

try {

rs.close();

psmt.close();

conn.close();

} catch (SQLException e) {

e.printStackTrace();

}

第二查询返回对象

spring总结

第一个参数：sql语句

第二个参数：RowMapper，是接口，类似于dbutils里的接口

第三个参数：可变参数

public class JdbcTemplateDemo2 {

//3.查询返回对象

@Test

public void testObject(){

//.创建对象，设置数据库信息

DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8");

dataSource.setUsername("root");

dataSource.setPassword("root");

//.创建jdbcTemplate对象，设置数据源

JdbcTemplate jdbcTemplate =new JdbcTemplate(dataSource);

//.写sql语句，根据username查询

String sql="select * from user where username=?";

//调用jdbcTemplate的方法

//第二个参数是接口那就叫RowMapper，需要自己写类实现接口，自己做数据封装

User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "lucy");

System.out.println(user);

}

class MyRowMapper implements RowMapper<User> {

//方法等同于帮我们实现了一部分功能

@Override

public User mapRow(ResultSet rs, int num) throws SQLException {

//1.从结果集里面得到数据

String username= rs.getString("username");

String password= rs.getString("password");

//2.把得到的数据封装到对象里去

User user = new User();

user.setUsername(username);

user.setPassword(password);

return user;

}

第三个查询返回list集合

spring总结

public class JdbcTemplateDemo2 {

//1.查询对象返回list集合

public class JdbcTemplateDemo2 {

@Test

public void testList(){

//.创建对象，设置数据库信息

DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8");

dataSource.setUsername("root");

dataSource.setPassword("root");

//.创建jdbcTemplate对象，设置数据源

JdbcTemplate jdbcTemplate =new JdbcTemplate(dataSource);

//.调用方法得到记录数

String sql="select * from user";

//调用jdbcTemplate的方法

List<User> list = jdbcTemplate.query(sql, new MyRowMapper());

System.out.println(list);

}

class MyRowMapper implements RowMapper<User> {

//方法等同于帮我们实现了一部分功能

@Override

public User mapRow(ResultSet rs, int num) throws SQLException {

//1.从结果集里面得到数据

String username= rs.getString("username");

String password= rs.getString("password");

//2.把得到的数据封装到对象里去

User user = new User();

user.setUsername(username);

user.setPassword(password);

return user;

}

c3p0连接池

Spring配置连接池和dao使用jdbcTemplate

1. spring配置c3p0连接池

第一步：导入相关jar包

spring总结

附：c3p0最原始写法：

ComboPooledDataSource dataSource = new ComboPooledDataSource();

dataSource.setDriverClass("com.mysql.jdbc.Driver");

dataSource.setUrl("jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8");

dataSource.setUser("root");

dataSource.setPassword("root");

配置文件中配置c3p0连接池

<property name="jdbcUrl"

value="jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8"></property>

</bean>

2. dao使用jdbcTemplate

（1）创建service和dao，配置service和dao对象，在service注入dao对象

</bean>

代码：

public class UserService {

private UserDao userDao;

public void setUserDao(UserDao userDao) {

this.userDao = userDao;

}

(2)创建jdbcTemplate对象，把模板对象注入到Dao类

</bean>

public class UserDao {

//得到JbdcTemplate模板对象

private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this.jdbcTemplate = jdbcTemplate;

}

（2）在jdbcTemplate对象里注入dataSource

spring总结

</bean>

最终注解的图解

spring总结

添加add()方法，测试：

public class UserDao {

//得到JbdcTemplate模板对象

private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this.jdbcTemplate = jdbcTemplate;

}

//添加操作

public void add(){

String sql = "insert into user values(?,?)";

jdbcTemplate.update(sql, "贺秦峰","123");

}

public class UserService {

private UserDao userDao;

public void setUserDao(UserDao userDao) {

this.userDao = userDao;

}

public void add(){

userDao.add();

}

public class TestService {

@Test

public void testDemo(){

ApplicationContext context=new

ClassPathXmlApplicationContext("applicationContext3.xml");

UserService userService = (UserService) context.getBean("userService01");

userService.add();

}

Spring的事务管理

事务概念

1. 什么是事务？

事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。

2. 事务特性

（1）原子性：一组操作，要么都成功，一个失败则全部失败

（2）一致性：前后数据总量不变

（3）隔离性：多个事务同时操作同一记录，之间互不影响

（4）持久性：事务提交之后，数据库真实生效。

3. 不考虑隔离级别产生读问题

4. 解决读问题

（1）设置隔离级别

Spring事务管理api

1. spring事务管理分两种方式

第一种：编程式事务管理

第二种：声明式事务管理

（1）基于xml配置文件实现

（2）基于注解实现

2. spring事务管理的api介绍

spring总结

（1）spring针对不同的dao层框架，提供接口不同的实现类

spring总结

搭建转账环境

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

spring总结

2. 创建service和dao类完成注入关系

（1）service层幼教业务逻辑层（建两个包）

package com.game79.service;

import com.game79.Dao.OrdersDao;

public class OrdersService {

private OrdersDao ordersDao;

public void setOrdersDao(OrdersDao ordersDao) {

this.ordersDao = ordersDao;

}

//调用dao层方法

//业务逻辑层，写转账业务

public void accountMoney(){

//小王少1000

ordersDao.lessMoney();

//出现异常

int i= 10/0;

//小马多1000

ordersDao.moreMoney();

}

（2）dao层，单纯对数据库操作层，在dao层不添加业务

package com.game79.Dao;

import org.springframework.jdbc.core.JdbcTemplate;

public class OrdersDao {

private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this.jdbcTemplate = jdbcTemplate;

}

/**

* 做对数据库操作的方法，不写业务操作

//小王少钱的方法

public void lessMoney(){

String sql ="update account set salary=salary-? where username=?";

jdbcTemplate.update(sql,1000,"小王");

}

//小马多钱的方法

public void moreMoney(){

String sql ="update account set salary=salary+? where username=?";

jdbcTemplate.update(sql,1000,"小马");

}

添加约束后的配置文件，简单的转账就这些配置

<?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: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/tx

http://www.springframework.org/schema/tx/spring-tx.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd">

<property name="jdbcUrl"

value="jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8"></property>

</bean>

</bean>

</bean>

</bean>

</beans>

3. 产生的问题

（1）如果小王少了1000之后，出现了异常，小马就不会多1000，钱就丢失了。

4. 解决方法

（1）添加事务解决，出现异常做回滚操作。

声明式事务管理（xml配置）

第一步：配置事务管理器

第二步：配置事务增强

第三步：配置切面

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

</bean>

<tx:advice id="txadvice" transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="account*" propagation="REQUIRED" />

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut expression="execution(* com.game79.service.OrdersService.*(..))"

id="pointcut01" />

<aop:advisor advice-ref="txadvice" pointcut-ref="pointcut01" />

</aop:config>

注：看到上述配置，我提出一个疑问，就是在第二步中的

<tx:method name="account*" propagation="REQUIRED" />

配置中已经制定在account方法上加事务操作（在其上加入增强），而第三步操作中，切入点

<aop:pointcut expression="execution(* com.game79.service.OrdersService.*(..))"

id="pointcut01" />

<aop:advisor advice-ref="txadvice" pointcut-ref="pointcut01" />

中表达式也将实际增强到具体方法上。难道不是指定重复了吗？

解答：

理解错误：第二步操作上，只是声明，并未增强。

<aop:pointcut expression="* com.game79.OrdersService.*.*(..)" id="pointcut01"/>

这里定义了切入点是：com.game79.OrdersService包下的所有类的全部方法。

tx:method name="account*" 这里声明的方法如果包含在切入点里则表示作为一个事务执行。

个人认为：事务操作都是从切入点开始的，可以把切入点看作是一个入口，即使是声明了account*这样的方法做事务操作，但是不符合切入点表达式的要求，则（拒绝入内）无法进行增强（若是事务操作，则事务不生效）。

声明式事务管理（注解）

第一步：配置事务管理器

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

</bean>

第二步：配置事务注解

<tx:annotation-driven transaction-manager="transactionManager" />

第三步：要使用事务的方法所在的类上添加注解

spring总结

完整测试代码

1. OrdersDao类（注意包名不同）

package com.game79.Dao;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.stereotype.Component;

@Component(value="ordersDao")

public class OrdersDao {

@Autowired

private JdbcTemplate jdbcTemplate;

//public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

//this.jdbcTemplate = jdbcTemplate;

//}

/**

* 做对数据库操作的方法，不写业务操作

//小王少钱的方法

public void lessMoney(){

String sql ="update account set salary=salary-? where username=?";

jdbcTemplate.update(sql,1000,"小王");

}

//小马多钱的方法

public void moreMoney(){

String sql ="update account set salary=salary+? where username=?";

jdbcTemplate.update(sql,1000,"小马");

}

2. OrdersService类

package com.game79.service;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import com.game79.Dao.OrdersDao;

@Transactional

@Service(value="ordersService")

public class OrdersService {

@Autowired

private OrdersDao ordersDao;

//public void setOrdersDao(OrdersDao ordersDao) {

//this.ordersDao = ordersDao;

//}

//调用dao层方法

//业务逻辑层，写转账业务

public void accountMoney(){

//小王少1000

ordersDao.lessMoney();

//出现异常

int i= 10/0;

//小马多1000

ordersDao.moreMoney();

}

3. TestService类

package com.game79.service;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestService {

@Test

public void testDemo(){

ApplicationContext context=new

ClassPathXmlApplicationContext("applicationContext3.xml");

OrdersService ordersService = (OrdersService) context.getBean("ordersService");

ordersService.accountMoney();

}

4. 配置

<?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: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/tx

http://www.springframework.org/schema/tx/spring-tx.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop.xsd">

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

<property name="jdbcUrl"

value="jdbc:mysql://localhost:3306/spring_day03?serverTimezone=GMT%2B8"></property>

</bean>

<bean id="transactionManager"

class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

</bean>

<tx:annotation-driven transaction-manager="transactionManager" />

<!-- <bean id="ordersDao" class=" com.game79.Dao.OrdersDao">

</bean>

</bean> -->

</bean>

</beans>

spring总结

Spring学习（详细）

Spring 概念

Spring核心：IOC

Ioc底层原理

IOC入门案例

Spring的bean管理（xml配置文件）

bean实例化的三种方式

Bean标签的常用属性

属性注入

使用有参构造注入属性

使用set方法注入属性

注入对象类型的属性

P名称空间注入

复杂类型属性注入

IOC和DI区别

Spring的bean管理（注解）

注解

Spring注解开发准备

注解创建对象

注解注入属性

配置文件和注解混合使用

自我拓展全配置文件实现上述操作

Spring核心：AOP

Aop相关概念

AOP原理

Aop操作相关术语

springAOP操作

Aop操作准备

AOP增强配置方式

log4j

AOP增强注解方式

Spring的jdbcTemplate操作（jdbc模板操作）

增加

删除

修改

查询

c3p0连接池

Spring的事务管理

事务概念

Spring事务管理api

搭建转账环境

声明式事务管理（xml配置）

声明式事务管理（注解）

完整测试代码

相关推荐