1.简单自己实现IOC
pom.xml
<?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>com.darksnow</groupId>
<artifactId>SpringDemo01</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>7</source>
<target>7</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.6</version>
</dependency>
</dependencies>
</project>
beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userService" class="com.darksnow.service.impl.UserServiceImpl"/>
</beans>
service层代码
package com.darksnow.service.impl;
import com.darksnow.service.UserService;
public class UserServiceImpl implements UserService {
}
----------------------------------
package com.darksnow.service;
public interface UserService {
}
Beanfactory
package com.darksnow.factory;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class BeanFactory {
private static final Map<String,Object> map = new HashMap<>();
//用Map来存储对象，因为有查找需求，相当于一个容器对象，包含了所有对象
static {
//获取配置文件的输入流对象
InputStream inputStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
//解析xml，获取xml中的信息
SAXReader reader = new SAXReader();
try {
//创建文档对象
Document doc = reader.read(inputStream);
//获取根节点
Element root = doc.getRootElement();
//获取根节点中的所有子节点
List<Element> beanList = root.elements("bean");
//遍历获取每一个bean的id和class
for(Element element : beanList) {
String id = element.attributeValue("id");
String className = element.attributeValue("class");
//通过className全限类名创建对象
//获取字节码文件对象
Class<?> clazz = Class.forName(className);
//通过反射创建对象
Object obj = clazz.newInstance();
//存储到Map集合中
map.put(id,obj);
}
} catch (Exception e) {
e.printStackTrace();
}
}
//需要实现的功能：传入一个id值，获取对应的Bean对象
public static Object getBean(String id){
return map.get(id);
}
}
测试类
package com.darksnow.test;
import com.darksnow.factory.BeanFactory;
public class TestIoc {
public static void main(String[] args) {
Object userService = BeanFactory.getBean("userService");
System.out.println(userService);
Object main = BeanFactory.getBean("main");
System.out.println(main);
}
}
2.Spring入门案例
pom.xml
<?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>com.darksnow</groupId>
<artifactId>SpringDemo01</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
配置文件
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
scope属性取值：
prototype：对象的创建是多例模式
singleton：对象的创建是单例模式(默认的)
-->
<bean id="userDao" class="com.darksnow.dao.impl.UserDaoImpl" scope="singleton" init-method="init" destroy-method="destroy"/>
</beans>
接口与实现类
package com.darksnow.dao;
public interface UserDao {
}
-----------------------------------------------------------
package com.darksnow.dao.impl;
import com.darksnow.dao.UserDao;
public class UserDaoImpl implements UserDao {
public void init() {
System.out.println("userDao的初始化....");
}
public void destroy() {
System.out.println("userDao的销毁....");
}
}
测试类
package com.darksnow.test;
import com.darksnow.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpringIoc {
public static void main(String[] args) {
//1.创建Spring的IOC容器
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//创建容器对象时，创建对象，只创建单例模式的对象，多例模式的对象在获取时创建
//单例模式的对象在创建容器时创建，销毁容器时销毁
//多例模式的对象在获取时创建，即使容器被销毁，对象也不见得立马被销毁，当对象长时间不再被引用，则被垃圾回收机制回收
Object userDao = ac.getBean("userDao");
System.out.println(userDao);
UserDao userDao1 = ac.getBean(UserDao.class);
System.out.println(userDao1);
UserDao userDao2 = ac.getBean("userDao", UserDao.class);
System.out.println(userDao2);
//ac.close(); 销毁容器，ClassPathXmlApplicationContext里面的方法
}
}
3.实例化Bean的三种方式
3.1 实例工厂
package com.darksnow.factory;
import com.darksnow.dao.UserDao;
import com.darksnow.dao.impl.UserDaoImpl;
public class InstanceFactory {
public UserDao getUserDao() {
return new UserDaoImpl();
}
}
3.2 静态工厂
package com.darksnow.factory;
import com.darksnow.dao.UserDao;
import com.darksnow.dao.impl.UserDaoImpl;
public class StaticFactory {
public static UserDao getUserDao() {
return new UserDaoImpl();
}
}
3.3 applicationContext.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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 方式一：通过xml方式配置 -->
<bean id="userDao1" class="com.darksnow.dao.impl.UserDaoImpl" />
<!-- 方式二：实例工厂 -->
<!-- 创建实例工厂 -->
<bean id="instanceFactory" class="com.darksnow.factory.InstanceFactory"/>
<!-- 通过实例工厂创建UserDaoImpl对象 -->
<bean id="userDao2" factory-bean="instanceFactory" factory-method="getUserDao"/>
<!-- 方式三：静态工厂 -->
<bean id="userDao3" class="com.darksnow.factory.StaticFactory" factory-method="getUserDao"/>
</beans>
3.4 测试类
package com.darksnow.test;
import com.darksnow.dao.UserDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpringIoc {
public static void main(String[] args) {
//创建Spring的IOC容器
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
//方式一：通过xml方式来实例化Bean
UserDao userDao1 = ac.getBean("userDao1", UserDao.class);
System.out.println(userDao1);
//方式二：通过实例工厂来实例化Bean
UserDao userDao2 = ac.getBean("userDao2", UserDao.class);
System.out.println(userDao2);
//方式三：通过静态工厂来实例化Bean
UserDao userDao3 = ac.getBean("userDao3", UserDao.class);
System.out.println(userDao3);
}
}
4.Spring的依赖注入
4.1 构造方法注入
User实体
package com.darksnow.pojo;
import java.util.Date;
public class User {
private Integer id;
private String username;
private Character sex;
private Date birthday;
public User() {
}
public User(Integer id, String username, Character sex, Date birthday) {
this.id = id;
this.username = username;
this.sex = sex;
this.birthday = birthday;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", sex=" + sex +
", birthday=" + birthday +
'}';
}
}
配置文件
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--
依赖注入
默认创建对象的方式：使用默认的无参构造方法创建对象
但是我们也可以基于带参构造方法创建对象
-->
<bean id="user" class="com.darksnow.pojo.User">
<!-- 通过构造方法上参数的索引进行赋值 -->
<constructor-arg index="0" value="1"/>
<constructor-arg index="1" value="darksnow"/>
<!-- 通过构造方法上参数的类型进行赋值 -->
<constructor-arg type="java.lang.Character" value="男"/>
<!--
value：该属性只能赋值简单的类型和String类型
ref：pojo等复杂类型，可以关联创建好的对象
-->
<constructor-arg name="birthday" ref="birthday"/>
</bean>
<bean id="birthday" class="java.util.Date"/>
</beans>
测试类
package com.darksnow.test;
import com.darksnow.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.Date;
public class TestSpringDi {
public static void main(String[] args) {
//创建Spring的IOC容器
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
User user = ac.getBean("user", User.class);
System.out.println(user);
}
}
4.2 set方法注入和p名称空间注入
User实体
package com.darksnow.pojo;
import java.util.Date;
public class User {
private Integer id;
private String username;
private Character sex;
private Date birthday;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Character getSex() {
return sex;
}
public void setSex(Character sex) {
this.sex = sex;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", username='" + username + '\'' +
", sex=" + sex +
", birthday=" + birthday +
'}';
}
}
配置文件
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="birthday" class="java.util.Date"/>
<!-- 通过set方法注入 -->
<bean id="user" class="com.darksnow.pojo.User">
<property name="id" value="110"/>
<property name="username" value="安欣"/>
<property name="sex" value="男" />
<property name="birthday" ref="birthday" />
</bean>
<!-- 使用p名称空间注入（基于set方法） -->
<bean id="user2" class="com.darksnow.pojo.User" p:id="520" p:username="孟钰" p:sex="女" p:birthday-ref="birthday"/>
</beans>
测试类
package com.darksnow.test;
import com.darksnow.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestSpringDi {
public static void main(String[] args) {
//创建Spring的IOC容器
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
User user = ac.getBean("user", User.class);
System.out.println(user);
User user2 = ac.getBean("user2", User.class);
System.out.println(user2);
}
}
4.3 集合注入
User实体
package com.darksnow.pojo;
import java.util.*;
public class User {
private List<String> list;
private Set<String> set;
private String[] strs;
private Map<String,String> map;
private Properties prop;
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
public Set<String> getSet() {
return set;
}
public void setSet(Set<String> set) {
this.set = set;
}
public String[] getStrs() {
return strs;
}
public void setStrs(String[] strs) {
this.strs = strs;
}
public Map<String, String> getMap() {
return map;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public Properties getProp() {
return prop;
}
public void setProp(Properties prop) {
this.prop = prop;
}
}
配置文件
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="birthday" class="java.util.Date"/>
<bean id="user" class="com.darksnow.pojo.User">
<!-- array，list，set结构相同，标签可以混用 -->
<!-- list集合注入 -->
<property name="list">
<list>
<value>强哥</value>
<value>刀哥</value>
<value>小江</value>
</list>
</property>
<!-- set集合注入 -->
<property name="set">
<set>
<value>书婷</value>
<value>黄瑶</value>
<value>老默</value>
</set>
</property>
<!-- 数组注入 -->
<property name="strs">
<array>
<value>高启强</value>
<value>高启盛</value>
<value>高启兰</value>
</array>
</property>
<!-- map集合注入，map和properties结构相同，可以混用 -->
<property name="map">
<map>
<entry key="1" value="李响"/>
<entry key="2" value="谭思言"/>
</map>
</property>
<!-- properties注入 -->
<property name="prop">
<props>
<prop key="666">李有田</prop>
<prop key="777">李宏伟</prop>
</props>
</property>
</bean>
</beans>
测试类
package com.darksnow.test;
import com.darksnow.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.Arrays;
public class TestSpringDi {
public static void main(String[] args) {
//创建Spring的IOC容器
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
User user = ac.getBean("user", User.class);
System.out.println(user.getList());
System.out.println(user.getSet());
System.out.println(Arrays.toString(user.getStrs()));
System.out.println(user.getMap());
System.out.println(user.getProp());
}
}
5.CRUD案例
配置文件
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
<constructor-arg ref="comboPooledDataSource"/>
</bean>
<bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql:///darksnow?CharacterEncoding=utf-8"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>
</beans>
实体类
package com.darksnow.pojo;
public class Account {
private Integer id;
private String name;
private Float money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Float getMoney() {
return money;
}
public void setMoney(Float money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
dao层
package com.darksnow.dao;
import com.darksnow.pojo.Account;
import java.sql.SQLException;
import java.util.List;
public interface AccountDao {
List<Account> findAll() throws SQLException;
Account findById(Integer id) throws SQLException;
void save(Account account) throws SQLException;
void update(Account account) throws SQLException;
void delete(Integer id) throws SQLException;
}
-----------------------------------------
package com.darksnow.dao.impl;
import com.darksnow.dao.AccountDao;
import com.darksnow.pojo.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import java.sql.SQLException;
import java.util.List;
@Repository
public class AccountDaoImpl implements AccountDao {
@Autowired
private QueryRunner runner;
public List<Account> findAll() throws SQLException {
String sql = "select * from account";
return runner.query(sql,new BeanListHandler<Account>(Account.class));
}
public Account findById(Integer id) throws SQLException {
String sql = "select * from account where id = ?";
return runner.query(sql,new BeanHandler<Account>(Account.class),id);
}
public void save(Account account) throws SQLException {
String sql = "insert into account values(?,?,?)";
runner.update(sql,null,account.getName(),account.getMoney());
}
public void update(Account account) throws SQLException {
String sql = "update account set name = ? where id = ?";
runner.update(sql,account.getName(),account.getId());
}
public void delete(Integer id) throws SQLException {
String sql = "delete from account where id = ?";
runner.update(sql,id);
}
}
service层
package com.darksnow.service;
import com.darksnow.pojo.Account;
import java.sql.SQLException;
import java.util.List;
public interface AccountService {
List<Account> findAll() throws SQLException;
Account findById(Integer id) throws SQLException;
void save(Account account) throws SQLException;
void update(Account account) throws SQLException;
void delete(Integer id) throws SQLException;
}
-----------------------------------------
package com.darksnow.service.impl;
import com.darksnow.dao.AccountDao;
import com.darksnow.pojo.Account;
import com.darksnow.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.sql.SQLException;
import java.util.List;
/*
* @Component只要标记了该注解，并且标记该注解的类在扫描范围内，就会创建对象
* 需要在xml配置文件中配置 <context:component-scan base-package="你要扫描的包路径，该路径下的所有类都会被扫描到"/>
*
* 除了上述注解还有三个
* @Controller 一般用于web层
* @Service 一般用于service层
* @Repository 一般用于dao层
*/
//@Service //如果没有指定名称，默认是简单类名(但是首字母小写)，比如：类名为UserServiceImpl，getBean的时候就用userServiceImpl
@Service("accountService") //主句话相当于，你在xml中配置<bean id="accountService" class="com.darksnow.service.impl.AccountServiceImpl">
public class AccountServiceImpl implements AccountService {
/*
必须与@Autowired结合使用
作用：如果自动注入按照类型注入失败，则按照指定的名称注入
不是很常用，了解
*/
//@Qualifier("accountDao")
/*
@Autowired 可以自动按照类型注入
当属性或者set方法标记了@Autowired，会自动在容器中查找该属性类型的对象，如果有多个则会选择名字相同的
*/
//@Autowired
/*
一样可以自动按照类型注入，但是不同于@Autowired的是，它是不是有Spring提供的而是JDK
而且它还能够按照指定的名称注入，但是@Autowired不行！
*/
//@Resource(name = "accountDaoImpl")
@Resource
private AccountDao accountDao;
public List<Account> findAll() throws SQLException {
System.out.println(accountDao);
return accountDao.findAll();
}
public Account findById(Integer id) throws SQLException {
return accountDao.findById(id);
}
public void save(Account account) throws SQLException {
accountDao.save(account);
}
public void update(Account account) throws SQLException {
accountDao.update(account);
}
public void delete(Integer id) throws SQLException {
accountDao.delete(id);
}
}
测试类
package com.darksnow.test;
import com.darksnow.dao.AccountDao;
import com.darksnow.pojo.Account;
import com.darksnow.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.sql.SQLException;
import java.util.List;
public class TestCrud {
private ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
private AccountService accountService = ac.getBean("accountService", AccountService.class);
@Test
public void testFindAll() throws SQLException {
List<Account> accountList = accountService.findAll();
for (Account account : accountList) {
System.out.println(account);
}
}
@Test
public void testFindById() throws SQLException {
Account account = accountService.findById(1);
System.out.println(account);
}
@Test
public void testSave() throws SQLException {
Account account = new Account();
account.setName("康健");
account.setMoney(1500f);
accountService.save(account);
}
@Test
public void testUpdate() throws SQLException {
Account account = new Account();
account.setId(3);
account.setName("康康建");
accountService.update(account);
}
@Test
public void testDelete() throws SQLException {
accountService.delete(3);
}
}
6.纯注解CRUD案例(无xml)
基于原来的CRUD案例，dao层和service层，pojo代码没有做任何修改
配置类
package com.darksnow.config;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import javax.sql.DataSource;
import java.beans.PropertyVetoException;
@Configuration
//加载properties配置文件
@PropertySource({"jdbc.properties"})
public class JdbcConfiguration {
//给属性赋值，只能给简单类型赋值
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
//@Bean("name")，用在方法上，用来指定方法创建的对象存储到容器中，name就是在容器中的名称
@Bean("queryRunner")
public QueryRunner createQueryRunner(DataSource dataSource) {
return new QueryRunner(dataSource);
}
@Bean("dataSource")
public DataSource createDataSource() {
ComboPooledDataSource dataSource = new ComboPooledDataSource();
try {
dataSource.setDriverClass(driver);
dataSource.setJdbcUrl(url);
dataSource.setUser(username);
dataSource.setPassword(password);
}catch (PropertyVetoException e){
e.printStackTrace();
}
return dataSource;
}
}
-----------------------------------
package com.darksnow.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
//该注解用于标记指定类为配置文件类
@Configuration
//相当于<context:component-scan base-package="com.darksnow" />
@ComponentScan({"com.darksnow"})
//引入其他配置类
@Import({JdbcConfiguration.class})
public class SpringConfiguration {
}
测试类
package com.darksnow.test;
import com.darksnow.config.SpringConfiguration;
import com.darksnow.pojo.Account;
import com.darksnow.service.AccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.sql.SQLException;
import java.util.List;
public class TestCrud {
@Test
public void testFindAll() throws SQLException {
//存注解创建容器对象
ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
AccountService accountService = ac.getBean("accountService", AccountService.class);
List<Account> accountList = accountService.findAll();
for (Account account : accountList) {
System.out.println(account);
}
}
}
其他注解
//配置对象的模式，默认是单例，配置在类上
@Scope("singleton")
//写在方法上，相当于bean标签内的属性：init-method，指定初始化方法
@PostConstruct
//写在方法上，相当于bean标签内的属性：destroy-method，指定对象的销毁方法
@PreDestroy
7.xml加载properties
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 在xml中引入其他的配置文件 -->
<!-- <import resource="applicationContext-dao.xml"/> -->
<!-- 加载properties配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
<constructor-arg ref="comboPooledDataSource"/>
</bean>
<bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- ${jdbc.driver} 获取的是properties中的配置 -->
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
</beans>
8.Spring与Junit整合
<!-- 引入依赖坐标 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
8.1 xml的形式
package com.darksnow.test;
import com.darksnow.pojo.Account;
import com.darksnow.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.sql.SQLException;
import java.util.List;
//替换Junit的运行器为spring与junit整合后的运行器
@RunWith(SpringJUnit4ClassRunner.class)
//指定配置文件路径，会自动创建容器对象
@ContextConfiguration({"classpath:applicationContext.xml"})
public class TestCrud {
@Autowired
private AccountService accountService;
@Test
public void testFindAll() throws SQLException {
List<Account> accountList = accountService.findAll();
for (Account account : accountList) {
System.out.println(account);
}
}
}
8.2 纯注解的形式
package com.darksnow.test;
import com.darksnow.config.SpringConfiguration;
import com.darksnow.pojo.Account;
import com.darksnow.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.sql.SQLException;
import java.util.List;
//替换Junit的运行器为spring与junit整合后的运行器
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfiguration.class})
public class TestCrud {
@Autowired
private AccountService accountService;
@Test
public void testFindAll() throws SQLException {
List<Account> accountList = accountService.findAll();
for (Account account : accountList) {
System.out.println(account);
}
}
}
9.动态代理
9.1 JDK动态代理
package com.darksnow.proxy;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.junit.Test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
class ProductFactory {
//制造产品
public void make() {
System.out.println("生产了一个产品");
}
}
//建立一个销售的网点：直营
class OldSale {
public void sale(Float money) {
System.out.println("正在以" + money + "价格卖出");
}
}
//总经销商
interface NewSale {
//卖产品
void sale(Float money);
}
//经销商创建的销售网点
class NewSaleImpl implements NewSale {
public void sale(Float money) {
System.out.println("正在以" + money + "价格卖出");
}
}
public class TestProxy {
//JDK动态代理：基于接口的动态代理
@Test
public void testJDKProxy() {
//代理之前对象
NewSale newSale = new NewSaleImpl();
//newSale.sale(2000F);
/*
对卖出方法进行增强，可以判断我以某个价格卖出是亏了还是赚了
TestProxy.class.getClassLoader()：类加载器
newSale.getClass().getInterfaces()：实现类的接口数组
new InvocationHandler()：以匿名内部类的方式实现了InvocationHandler接口，具体的增强逻辑写在覆盖该接口中的invoke方法中
*/
NewSale sale = (NewSale) Proxy.newProxyInstance(TestProxy.class.getClassLoader(), newSale.getClass().getInterfaces(), new InvocationHandler() {
/*
Object proxy：代理对象
Method method：代理的方法，原来未增强的方法
Object[] args：代理的方法的参数
返回值：代理的方法的返回值
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//生产产品
ProductFactory productFactory = new ProductFactory();
productFactory.make();
/*
开始销售
invoke方法的参数
参数1：要增强的方法所在的对象
参数2：要增强的方法的参数
*/
method.invoke(newSale, args); //调用的是原来没有增强的方法
if ((Float) args[0] > 1500) {
System.out.println("卖的价格高于成本，挣了，可卖");
} else {
System.out.println("卖的价格低于成本，赔了，不可卖");
}
return null;
}
});
sale.sale(2000F);
}
}
9.2 cglib动态代理
//cglib动态代理：基于类的动态代理
@Test
public void testCglibProxy() {
//cglib动态代理，代理对象是要增强的方法所在的对象的一个子类
//要增强的方法所在的对象，要增强的方法为OldSale对象中的sale(Float money)方法
OldSale oldSale = new OldSale();
//创建cglib代理对象
//1.创建增强类对象
Enhancer enhancer = new Enhancer();
//2.指定代理对象的父类
enhancer.setSuperclass(OldSale.class);
//3.指定增强的内容
//MethodInterceptor接口是方法拦截器，拦截方法进行增强
enhancer.setCallback(new MethodInterceptor() {
/*
参数说明
Object o：代理对象，增强后的对象
Method method：代理的方法
Object[] objects：代理的方法的参数
MethodProxy methodProxy：代理方法，增强后的方法
*/
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
//生产产品
ProductFactory productFactory = new ProductFactory();
productFactory.make();
//开始销售，执行原来要增强的方法
method.invoke(oldSale,objects);
if ((Float) objects[0] > 1500) {
System.out.println("卖的价格高于成本，挣了，可卖");
} else {
System.out.println("卖的价格低于成本，赔了，不可卖");
}
return null;
}
});
//4.创建代理对象
OldSale oldSaleProxy = (OldSale) enhancer.create();
oldSaleProxy.sale(500F);
}
10.动态代理增强转账业务
配置文件
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 加载properties配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
<constructor-arg ref="dataSource"/>
</bean>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- ${jdbc.driver} 获取的是properties中的配置 -->
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
</beans>
工具类
package com.darksnow.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
/*
一个管理连接的工具类，用于实现连接和线程的绑定
*/
@Component
public class ConnectionUtil {
private final ThreadLocal<Connection> tl = new ThreadLocal<>();
@Autowired
private DataSource dataSource;
/*
获取当前线程上绑定的连接
*/
public Connection getThreadConnection() {
try {
Connection conn = tl.get();
//判断线程上是否绑了
if (conn == null) {
//从数据源中获取一个连接
conn = dataSource.getConnection();
//和线程绑定
tl.set(conn);
}
//返回线程上的连接
return tl.get();
}catch (SQLException e){
throw new RuntimeException(e);
}
}
/*
把连接和当前线程解绑
*/
public void remove() {
tl.remove();
}
}
package com.darksnow.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.sql.SQLException;
/*
事务管理器
*/
@Component
public class TransactionManager {
@Autowired
private ConnectionUtil connectionUtil;
//开始事务
public void beginTransaction() {
//从当前线程上获取连接，实现开启事务
try {
connectionUtil.getThreadConnection().setAutoCommit(false);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
//提交事务
public void commit() {
try {
connectionUtil.getThreadConnection().commit();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
//回滚事务
public void rollback() {
try {
connectionUtil.getThreadConnection().rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
//释放连接
public void release() {
try {
connectionUtil.getThreadConnection().setAutoCommit(true);
//关闭连接
connectionUtil.getThreadConnection().close();
//解绑线程
connectionUtil.remove();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
实体类
package com.darksnow.pojo;
public class Account {
private Integer id;
private String name;
private Float money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Float getMoney() {
return money;
}
public void setMoney(Float money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
dao层
package com.darksnow.dao;
import com.darksnow.pojo.Account;
import java.sql.SQLException;
public interface AccountDao {
Account findByName(String fromName) throws SQLException;
void update(Account account) throws SQLException;
}
-----------------------------------------
package com.darksnow.dao.impl;
import com.darksnow.dao.AccountDao;
import com.darksnow.pojo.Account;
import com.darksnow.utils.ConnectionUtil;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import java.sql.Connection;
import java.sql.SQLException;
@Repository
public class AccountDaoImpl implements AccountDao {
@Autowired
private ConnectionUtil connectionUtil;
@Autowired
private QueryRunner queryRunner;
//根据账户名查询账户
@Override
public Account findByName(String fromName) throws SQLException {
String sql = "select * from account where name = ?";
//从线程中获取一个连接对象
Connection conn = connectionUtil.getThreadConnection();
return queryRunner.query(conn,sql,new BeanHandler<Account>(Account.class),fromName);
}
//更新账户
@Override
public void update(Account account) throws SQLException {
String sql = "update account set money = ? where name = ?";
Connection conn = connectionUtil.getThreadConnection();
queryRunner.update(conn, sql, account.getMoney(), account.getName());
}
}
service层
package com.darksnow.service;
public interface AccountService {
void transfer(String fromName, String toName, Float money);
}
------------------------------------
package com.darksnow.service.impl;
import com.darksnow.dao.AccountDao;
import com.darksnow.pojo.Account;
import com.darksnow.service.AccountService;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.sql.SQLException;
/*
一个事务必须在一个Connection中完成
ThreadLocal：线程绑定，绑定Connection对象，业务层和持久层需要Connection就从ThreadLocal中获取
*/
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Override
public void transfer(String fromName, String toName, Float money) {
try {
//查询要转出的账号
Account fromAccount = accountDao.findByName(fromName);
//查询要转入的账号
Account toAccount = accountDao.findByName(toName);
//修改要转出的账户余额
fromAccount.setMoney(fromAccount.getMoney() - money);
//修改要转入的账户余额
toAccount.setMoney(toAccount.getMoney() + money);
//持久化到数据库
accountDao.update(fromAccount);
// int i = 1/0;
accountDao.update(toAccount);
}catch (SQLException e) {
e.printStackTrace();
}
}
}
测试类
package com.darksnow.test;
import com.darksnow.service.AccountService;
import com.darksnow.utils.TransactionManager;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestTransfer {
@Autowired
private AccountService accountService;
@Autowired
private TransactionManager txManager;
@Test
public void transfer() {
accountService.transfer("张三","李四",500f);
}
@Test
public void testJDKProxyService() {
AccountService accountServiceProxy = (AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
//开启事务
txManager.beginTransaction();
//执行未增强之前的方法
method.invoke(accountService, args);
//提交事务
txManager.commit();
} catch (Exception e) {
//事务回滚
txManager.rollback();
e.printStackTrace();
} finally {
//还原状态
txManager.release();
}
return null;
}
});
accountServiceProxy.transfer("张三", "李四", 500f);
}
@Test
public void testCglibProxyService() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(accountService.getClass());
enhancer.setCallback(new MethodInterceptor() {
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
try {
txManager.beginTransaction();
method.invoke(accountService,objects);
txManager.commit();
}catch (Exception e) {
txManager.rollback();
e.printStackTrace();
}finally {
txManager.release();
}
return null;
}
});
AccountService as = (AccountService) enhancer.create();
as.transfer("张三","李四",500f);
}
}
11.AOP
11.1 概念
AOP：全称为Aspect Oriented Programming 即：面向切面编程
简单说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们已有的方法进行增强，所以底层基于jdk动态代理 + cglib动态代理的
作用：在程序运行期间，不修改源码对已有方法进行增强
优势：减少重复代码，松耦合，提高开发效率，维护起来比较便捷
注意：aop由多个oop组成（oop为面向对象编程）
11.2 AOP相关术语
Joinpoint(连接点)：所谓的连接点是指那些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持方法类型的连接点
Pointcut(切入点)：所谓的切入点是指我们要对那些Joinpoint进行拦截的定义
Advice(通知/增强)：所谓的通知是指拦截到Joinpoint之后所要做的事情就是通知
Target(目标对象)：代理的目标对象
Weaving(织入)：是指把增强应用到目标对象来创建新的代理对象的过程，spring采用动态代理织入，而aspect采用编译期织入和类装载期织入。
Proxy(代理)：一个类被Aop织入增强后，就产生一个结果代理类
Introduction(引介)：引介是一种特殊的通知，在不修改代码的前提下，引介可以在运行期为类动态地添加一些方法或字段
Aspect(切面)：它是切入点和通知(引介)的结合
11.3 AOP的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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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/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">
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="logger" class="com.darksnow.log.Logger" />
<!-- 配置Aop -->
<aop:config>
<!-- 配置切面 = 切入点 + 通知 -->
<aop:aspect ref="logger"> <!-- 指定通知的对象是谁 -->
<!--
配置切入点
属性说明：
id：唯一标识
expression：表达式
表达式说明：
* com.darksnow.service.impl.*.*(..)
第一个*：代表方法的返回值类型任意
第二个*：代表类名任意，impl包中的所有的类
第三个*：代表方法名任意
(..)：参数任意，个数任意，类型任意，顺序任意
表达式其他的配置方式：
* com.darksnow.service..*.*(..)
public void com.darksnow.service.impl.AccountService.findAll()
void com.darksnow.service.impl.AccountService.findAll()
* com.darksnow.service.impl.AccountService.findAll()
* com.darksnow.service..AccountService.findAll() 代表service包及其子包里的所有包都算
* *。。*。*(..)：全通配方式
-->
<aop:pointcut id="pointcut" expression="execution(* com.darksnow.service.impl.*.*(..))"/>
<!--
配置通知
织入：告诉通知对象执行，具体执行哪一个方法
通知的类型：
前置通知：方法之前执行
后置通知：方法执行完毕之后，返回之前执行，如果遇到异常则不执行
最终通知：方法执行完之后总会执行
异常通知：方法出现异常则执行
环绕通知：前置通知 + 后置通知 + 最终通知 + 异常通知
-->
<!-- 前置通知 -->
<!-- <aop:before method="before" pointcut-ref="pointcut"/>-->
<!-- 后置通知 -->
<!-- <aop:after-returning method="afterReturning" pointcut-ref="pointcut"/>-->
<!-- 最终通知 -->
<!-- <aop:after method="after" pointcut-ref="pointcut"/>-->
<!-- 异常通知 -->
<!-- <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/>-->
<!-- 环绕通知 -->
<aop:around method="around" pointcut-ref="pointcut" />
</aop:aspect>
</aop:config>
</beans>
service
package com.darksnow.service;
public interface AccoutService {
void print();
Integer add(int a,int b);
}
---------------------------------------------
package com.darksnow.service.impl;
import com.darksnow.service.AccoutService;
import org.springframework.stereotype.Service;
@Service
public class AccountServiceImpl implements AccoutService {
@Override
public void print() {
// int i = 1/0;
System.out.println("打印了......");
}
@Override
public Integer add(int a,int b) {
return a+b;
}
}
Logger类
package com.darksnow.log;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
//日志类，记录什么时间访问什么类，什么方法，操作什么功能
public class Logger {
public void before(JoinPoint joinPoint){
//获取被代理的对象
Object target = joinPoint.getTarget();
//被拦截的类的名称
String className = target.getClass().getName();
System.out.println("被拦截到的类名：" + className);
//获取方法对象
Signature signature = joinPoint.getSignature();
//获取被拦截的方法名
String methodName = signature.getName();
System.out.println("被拦截到的方法名：" + methodName);
System.out.println("前置通知......");
}
public void afterReturning() {
System.out.println("后置通知......");
}
public void after() {
System.out.println("最终通知......");
}
public void afterThrowing(Exception e) {
System.out.println("执行的方法的异常为：" + e);
System.out.println("异常通知......");
}
//ProceedingJoinPoint：可以执行拦到截的方法
public void around(ProceedingJoinPoint joinPoint) {
try {
System.out.println("前置通知......");
//执行原来要增强的方法，可以得到原来方法的返回值
Object result = joinPoint.proceed();
System.out.println(result);
System.out.println("后置增强......");
}catch (Throwable e) {
System.out.println("异常通知.....");
e.printStackTrace();
}finally {
System.out.println("最终通知......");
}
}
}
测试类
package com.darksnow.test;
import com.darksnow.service.AccoutService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestAopXml {
@Autowired
private AccoutService accoutService;
@Test
public void testAop() {
accoutService.print();
System.out.println("-------------------");
accoutService.add(1314,520);
}
}
11.4 AOP的注解形式
其他的和11.3的内容一样，以下为更改部分
配置文件
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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/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">
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<!-- 开启AOP的自动代理，注解方式代理 -->
<aop:aspectj-autoproxy />
</beans>
Logger类
package com.darksnow.log;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
//日志类，记录什么时间访问什么类，什么方法，操作什么功能
@Component //创建对象交给容器管理
@Aspect //配置该类为切面，切面 = 切入点 + 通知
public class Logger {
//配置切入点
@Pointcut("execution(* com.darksnow.service.impl.*.*(..))")
public void pointcut() {
}
//JoinPoint：连接点 --- 拦截到的方法
@Before("pointcut()") //织入
public void before(JoinPoint joinPoint){
//获取被代理的对象
Object target = joinPoint.getTarget();
//被拦截的类的名称
String className = target.getClass().getName();
System.out.println("被拦截到的类名：" + className);
//获取方法对象
Signature signature = joinPoint.getSignature();
//获取被拦截的方法名
String methodName = signature.getName();
System.out.println("被拦截到的方法名：" + methodName);
System.out.println("前置通知......");
}
@AfterReturning("pointcut()")
public void afterReturning() {
System.out.println("后置通知......");
}
@After("pointcut()")
public void after() {
System.out.println("最终通知......");
}
@AfterThrowing(value = "pointcut()",throwing = "e")
public void afterThrowing(Exception e) {
System.out.println("执行的方法的异常为：" + e);
System.out.println("异常通知......");
}
//ProceedingJoinPoint：可以执行拦到截的方法
// @Around("pointcut()")
public void around(ProceedingJoinPoint joinPoint) {
try {
System.out.println("前置通知......");
//执行原来要增强的方法，可以得到原来方法的返回值
Object result = joinPoint.proceed();
System.out.println(result);
System.out.println("后置增强......");
}catch (Throwable e) {
System.out.println("异常通知.....");
e.printStackTrace();
}finally {
System.out.println("最终通知......");
}
}
}
11.5 AOP配置式解决事务问题
照抄10.动态代理增强转账业务的代码，只是去掉动态代理增强的那两个测试方法
配置文件
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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/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">
<!-- 加载properties配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
<constructor-arg ref="dataSource"/>
</bean>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- ${jdbc.driver} 获取的是properties中的配置 -->
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!--
使用aop解决事务问题
-->
<aop:config>
<!-- 配置切面 -->
<aop:aspect ref="transactionManager"> <!-- 指定通知对象是谁 , 这里明显通知对象是 事务管理类 -->
<!-- 切入点 -->
<aop:pointcut id="pointcut" expression="execution(* com.darksnow.service.impl.*.*(..))"/>
<!-- 织入 -->
<!-- 前置通知(增强)：开启事务 -->
<aop:before method="beginTransaction" pointcut-ref="pointcut" />
<!-- 后置增强：提交事务 -->
<aop:after-returning method="commit" pointcut-ref="pointcut" />
<!-- 异常增强：回滚事务 -->
<aop:after-throwing method="rollback" pointcut-ref="pointcut" />
<!-- 最终增强：释放资源 -->
<aop:after method="release" pointcut-ref="pointcut" />
</aop:aspect>
</aop:config>
</beans>
测试类
package com.darksnow.test;
import com.darksnow.service.AccountService;
import com.darksnow.utils.TransactionManager;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestTransfer {
@Autowired
private AccountService accountService;
@Autowired
private TransactionManager txManager;
@Test
public void transfer() {
accountService.transfer("张三","李四",500f);
}
}
11.6 AOP注解式解决事务问题
照抄10.动态代理增强转账业务的代码，然后做如下修改
配置文件
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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/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">
<!-- 加载properties配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
<constructor-arg ref="dataSource"/>
</bean>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- ${jdbc.driver} 获取的是properties中的配置 -->
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 开启aop自动代理注解 -->
<aop:aspectj-autoproxy />
</beans>
事务管理类
package com.darksnow.utils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.sql.SQLException;
/*
事务管理器
*/
@Component
@Aspect //配置切面
public class TransactionManager {
@Autowired
private ConnectionUtil connectionUtil;
@Pointcut("execution(* com.darksnow.service.impl.*.*(..))")
public void pointcut(){
}
//环绕通知(增强)
@Around("pointcut()")
public void around(ProceedingJoinPoint joinPoint) {
try {
//前置增强
beginTransaction(); //开启事务
//执行原来未增强的方法
joinPoint.proceed();
//后置增强
commit(); //提交事务
}catch (Throwable throwable) {
//异常增强
rollback(); //回滚事务
throwable.printStackTrace();
}finally {
//最终增强
release(); //释放资源
}
}
//开始事务
public void beginTransaction() {
//从当前线程上获取连接，实现开启事务
try {
connectionUtil.getThreadConnection().setAutoCommit(false);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
//提交事务
public void commit() {
try {
connectionUtil.getThreadConnection().commit();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
//回滚事务
public void rollback() {
try {
connectionUtil.getThreadConnection().rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
//释放连接
public void release() {
try {
connectionUtil.getThreadConnection().setAutoCommit(true);
//关闭连接
connectionUtil.getThreadConnection().close();
//解绑线程
connectionUtil.remove();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
测试类
package com.darksnow.test;
import com.darksnow.service.AccountService;
import com.darksnow.utils.TransactionManager;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestTransfer {
@Autowired
private AccountService accountService;
@Autowired
private TransactionManager txManager;
@Test
public void transfer() {
accountService.transfer("张三","李四",500f);
}
}
12.JDBCTemplate的使用
pom.xml
<?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>com.darksnow</groupId>
<artifactId>SpringDemo01</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.18</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
</dependencies>
</project>
配置文件
<?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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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/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">
<!-- 加载properties配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
<constructor-arg ref="c3p0DataSource"/>
</bean>
<!-- 配置c3p0的数据源 -->
<bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- ${jdbc.driver} 获取的是properties中的配置 -->
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- Spring自带的数据源 -->
<bean id="springDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 创建JdbcTemplate模板对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="springDataSource" />
</bean>
</beans>
实体类
package com.darksnow.pojo;
public class Account {
private Integer id;
private String name;
private Float money;
//省略getter，setter，toString
}
结果集对象
package com.darksnow.mapper;
import com.darksnow.pojo.Account;
import org.springframework.jdbc.core.RowMapper;
import java.sql.ResultSet;
import java.sql.SQLException;
//结果集对象，只包含一行数据
public class AccountRomMapper implements RowMapper<Account> {
@Override
public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
Account account = new Account();
int id = rs.getInt("id");
account.setId(id);
account.setName(rs.getString("name"));
account.setMoney(rs.getFloat("money"));
return account;
}
}
测试类
package com.darksnow.test;
import com.darksnow.mapper.AccountRomMapper;
import com.darksnow.pojo.Account;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestJdbcTemplate {
@Autowired
private JdbcTemplate jdbcTemplate;
@Test
public void testFindAll() {
String sql = "select * from account";
//方式一：
// List<Map<String, Object>> accoutList = jdbcTemplate.queryForList(sql);
// for (Map<String, Object> map : accoutList) {
// System.out.println(map);
// }
//方式二：
//query方法参数一：sql语句，参数二：自定义结果集对象
List<Account> accountList = jdbcTemplate.query(sql, new AccountRomMapper());
for (Account account : accountList) {
System.out.println(account);
}
}
@Test
public void testFindById() {
String sql = "select * from account where id = ?";
//方式一：
// List<Account> accountList = jdbcTemplate.query(sql, new AccountRomMapper(), 20);
// System.out.println(accountList.size() == 1 ? accountList.get(0) : "结果为：null");
//方式二：
// Account account = jdbcTemplate.queryForObject(sql, new AccountRomMapper(), 2);
// System.out.println(account);
//方式三：
//BeanPropertyRowMapper对象会帮你做映射，但是使用的时候要保证属性和表中字段名一致
Account account = jdbcTemplate.queryForObject(sql, new Object[]{2}, new BeanPropertyRowMapper<>(Account.class));
System.out.println(account);
}
@Test
public void testSave() {
String sql = "insert into account values(null,?,?)";
jdbcTemplate.update(sql,"坤坤","0.01");
}
@Test
public void testUpdate() {
String sql = "update account set name = ? where id = ?";
jdbcTemplate.update(sql,"爱坤",3);
}
@Test
public void testDelete() {
String sql = "delete from account where id = ?";
jdbcTemplate.update(sql, 3);
}
@Test
public void testGetTotalCount() {
String sql = "select count(*) from account";
//queryForObject(sql语句，返回值类型)
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
System.out.println(count);
}
}
13.JDBCTemplate在dao层的使用
13.1 方式一
dao层
package com.darksnow.dao.impl;
import com.darksnow.dao.AccountDao;
import com.darksnow.mapper.AccountRomMapper;
import com.darksnow.pojo.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public class AccountDaoImpl implements AccountDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public List<Account> findAll() {
String sql = "select * from account";
return jdbcTemplate.query(sql,new AccountRomMapper());
}
@Override
public Account findById(Integer id) {
String sql = "select * from account where id = ?";
return jdbcTemplate.queryForObject(sql,new AccountRomMapper(),id);
}
}
测试类
package com.darksnow.test;
import com.darksnow.dao.AccountDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestJdbcTemplate {
@Autowired
private AccountDao accountDao;
@Test
public void testFindAll() {
System.out.println(accountDao.findAll());
}
@Test
public void testFindById() {
System.out.println(accountDao.findById(1));
}
}
13.2 方式二
dao层代码
package com.darksnow.dao.impl;
import com.darksnow.dao.AccountDao;
import com.darksnow.mapper.AccountRomMapper;
import com.darksnow.pojo.Account;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import java.util.List;
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
@Override
public List<Account> findAll() {
String sql = "select * from account";
return getJdbcTemplate().query(sql,new AccountRomMapper());
}
@Override
public Account findById(Integer id) {
String sql = "select * from account where id = ?";
return getJdbcTemplate().queryForObject(sql,new AccountRomMapper(),id);
}
}
测试类
package com.darksnow.test;
import com.darksnow.dao.AccountDao;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestJdbcTemplate {
@Autowired
private AccountDao accountDao;
@Test
public void testFindAll() {
System.out.println(accountDao.findAll());
}
@Test
public void testFindById() {
System.out.println(accountDao.findById(1));
}
}
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"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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/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">
<!-- 加载properties配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
<constructor-arg ref="c3p0DataSource"/>
</bean>
<!-- 配置c3p0的数据源 -->
<bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- ${jdbc.driver} 获取的是properties中的配置 -->
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- Spring自带的数据源 -->
<bean id="springDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 创建JdbcTemplate模板对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="springDataSource" />
</bean>
<!-- 创建dao层对象，交给容器管理 -->
<bean id="accountDao" class="com.darksnow.dao.impl.AccountDaoImpl">
<!-- 通过set方法注入数据源 -->
<property name="dataSource" ref="springDataSource"/>
</bean>
</beans>
14.Spring事务管理
脏读：
脏读又称无效数据读出（读出了脏数据）。一个事务读取另外一个事务还没有提交的数据叫脏读。
例如：事务T1修改了某个表中的一行数据，但是还没有提交，这时候事务T2读取了被事务T1修改后的数据，
之后事务T1因为某种原因回滚（Rollback）了，那么事务T2读取的数据就是脏的（无效的）。
幻读：
幻读的重点在于新增或者删除 (数据条数变化)， 同样的条件, 第1次和第2次读出来的记录数不一样。
例如：系统事务A将数据库中所有数据都删除的时候，但是事务B就在这个时候新插入了一条记录，
当事务A删除结束后发现还有一条数据，就好像发生了幻觉一样。这就叫幻读。
不可重复读：
不可重复读与脏读逻辑类似。主要在于事务2在事务1第二次读取时，提交了数据。导致事务1前后两次读取的数据不一致。
不可重复读的重点是修改并提交: 同样的条件, 你读取过的数据, 再次读取出来发现值不一样了
不可重复读是指在同一个事务内，两次相同的查询返回了不同的结果。
例如：事务T1会读取两次数据，在第一次读取某一条数据后，事务T2修改了该数据并提交了事务，
T1此时再次读取该数据，两次读取便得到了不同的结果。
-------------------------------------------------------------------
事务的四个特性(ACID)：
原子性(atomicity)：不可再分隔
一致性(consistency)：要么全部完成，要么全部不完成
隔离性(isolation)：事务之间的隔离级别
持久性(durability)：一旦提交，持久化到数据中
事务隔离级别：它反映了事务提交并发访问时的处理态度
（1）可以读取未提交数据(读未提交)：read_uncommitted
产生的问题：脏读，幻读，不可重复读
（2）只能读取已提交数据，解决脏读问题(Oracle默认级别，读已提交)：red_committed
产生的问题：幻读，不可重复读
解决的问题：脏读
（3）是否读取其他事务提交修改后的数据(Mysql默认级别，重复读)：repeatable_red
产生的问题：幻读
解决的问题：脏读，不可重复读
（4）是否读取其他事务提交添加后的数据(串行化)：serializable
产生的问题：无
解决的问题：脏读，幻读，不可重复读
隔离级别最高，效率最低
事务的传播行为：
（1）REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务，那么加入到这个事务中(默认值)
（2）MANDATORY：使用当前的事务，如果没有事务，就抛出异常
（3）NESTED：如果当前存在事务，则在嵌套事务内执行，如果当前没有事务，则执行REQUIRED类似的操作。
（4）NEVER：以非事务方式运行，如果当前存在事务，就抛出异常
（5）NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
（6）REQUIRES_NEW：新建事务，如果在事务中，把当前事务挂起
（7）SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行
14.1 Spring配置式事务管理
下面仅放修改了的代码，其他代码参考笔记"10.动态代理增强转账业务的代码"
pom.xml
<?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>com.darksnow</groupId>
<artifactId>SpringDemo01</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.18</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>
</dependencies>
</project>
配置文件
<?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:p="http://www.springframework.org/schema/p"
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
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 加载properties配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
<constructor-arg ref="c3p0DataSource"/>
</bean>
<!-- 配置c3p0的数据源 -->
<bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- ${jdbc.driver} 获取的是properties中的配置 -->
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- Spring自带的数据源 -->
<bean id="springDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 创建JdbcTemplate模板对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="springDataSource" />
</bean>
<!-- 创建事务管理对象 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- set注入数据源属性：事务在连接中，连接在连接池(数据源)中 -->
<property name="dataSource" ref="springDataSource" />
</bean>
<!--
配置事务的增强：过滤方法是否需要拦截
id：唯一标识
transaction-manager：指定事务管理对象
-->
<tx:advice id="txAdvice" transaction-manager="txManager">
<!-- 增强：方法过滤 -->
<tx:attributes>
<!--
指定需要拦截的方法
name属性：匹配方法名，*代表通配符匹配，比如find*，就代表find开头的都会匹配
isolation属性：设置事务的隔离级别，一般选默认
propagation属性：事务传播行为
read-only属性：是否为只读的事务，增删该设为非只读事务(false)，查询设为只读事务(true)
timeout属性：设置超时时间，默认为-1，意味着没有超时限制，单位为秒
-->
<tx:method name="insert*" isolation="DEFAULT" propagation="REQUIRED" read-only="false" timeout="-1"/>
<tx:method name="add*" />
<tx:method name="update*"/>
<tx:method name="del*" />
<tx:method name="delete*"/>
<tx:method name="save*"/>
<tx:method name="transfer*"/>
<!-- 查询 -->
<tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
<tx:method name="select*" propagation="SUPPORTS" read-only="true"/>
<tx:method name="get*" propagation="SUPPORTS" read-only="true"/>
</tx:attributes>
</tx:advice>
<aop:config>
<!--
配置切面
advice-ref：关联通知对象
pointcut：切入点
-->
<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.darksnow.service.impl.*.*(..))" />
</aop:config>
</beans>
dao层代码
package com.darksnow.dao;
import com.darksnow.pojo.Account;
import java.sql.SQLException;
public interface AccountDao {
Account findByName(String fromName) throws SQLException;
void update(Account account) throws SQLException;
}
----------------------------------------------------------
package com.darksnow.dao.impl;
import com.darksnow.dao.AccountDao;
import com.darksnow.mapper.AccountRomMapper;
import com.darksnow.pojo.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.sql.SQLException;
@Repository
public class AccountDaoImpl implements AccountDao {
@Autowired
private JdbcTemplate jdbcTemplate;
//根据账户名查询账户
@Override
public Account findByName(String fromName) throws SQLException {
String sql = "select * from account where name = ?";
//从线程中获取一个连接对象
return jdbcTemplate.queryForObject(sql,new AccountRomMapper(),fromName);
}
//更新账户
@Override
public void update(Account account) throws SQLException {
String sql = "update account set money = ? where name = ?";
jdbcTemplate.update(sql,account.getMoney(),account.getName());
}
}
映射结果集对象
package com.darksnow.mapper;
import com.darksnow.pojo.Account;
import org.springframework.jdbc.core.RowMapper;
import java.sql.ResultSet;
import java.sql.SQLException;
//结果集对象，只包含一行数据
public class AccountRomMapper implements RowMapper<Account> {
@Override
public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
Account account = new Account();
int id = rs.getInt("id");
account.setId(id);
account.setName(rs.getString("name"));
account.setMoney(rs.getFloat("money"));
return account;
}
}
测试类
package com.darksnow.test;
import com.darksnow.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestXmlTransaction {
@Autowired
private AccountService accountService;
@Test
public void testTransfer() {
accountService.transfer("张三","李四",1000f);
}
}
14.2 Spring注解式事务管理
下面仅放修改了的代码，其他代码参考笔记"14.1 Spring配置式事务管理"
配置文件
<?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:p="http://www.springframework.org/schema/p"
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
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 加载properties配置文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 需要扫描包才能够使用@Controller，@Service，@Repository，@Component -->
<context:component-scan base-package="com.darksnow" />
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner" >
<constructor-arg ref="c3p0DataSource"/>
</bean>
<!-- 配置c3p0的数据源 -->
<bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- ${jdbc.driver} 获取的是properties中的配置 -->
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- Spring自带的数据源 -->
<bean id="springDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- 创建JdbcTemplate模板对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="springDataSource" />
</bean>
<!-- 创建事务管理对象 -->
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- set注入数据源属性：事务在连接中，连接在连接池(数据源)中 -->
<property name="dataSource" ref="springDataSource" />
</bean>
<!-- transaction-manager：关联事务管理器对象 -->
<tx:annotation-driven transaction-manager="txManager" />
</beans>
service层实现类代码
package com.darksnow.service.impl;
import com.darksnow.dao.AccountDao;
import com.darksnow.pojo.Account;
import com.darksnow.service.AccountService;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import java.sql.SQLException;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
//放在类上就是整个类都有事务管理，放在方法上就只作用于该方法上
@Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED, readOnly = false, timeout = -1)
@Override
public void transfer(String fromName, String toName, Float money) {
try {
//查询要转出的账号
Account fromAccount = accountDao.findByName(fromName);
//查询要转入的账号
Account toAccount = accountDao.findByName(toName);
//修改要转出的账户余额
fromAccount.setMoney(fromAccount.getMoney() - money);
//修改要转入的账户余额
toAccount.setMoney(toAccount.getMoney() + money);
//持久化到数据库
accountDao.update(fromAccount);
int i = 1/0;
accountDao.update(toAccount);
}catch (SQLException e) {
e.printStackTrace();
}
}
}