aka-dbutils与SpringBoot 集成
aka-dbutils可以通过aka-dbutils-spring-starter模块与SpringBoot集成。与SpringBoot集成首先得在pom.xml里引入如下xml片段。
<dependency>
<artifactId>aka-dbutils-spring-boot-starter</artifactId>
<groupId>com.github.ulwx</groupId>
<version>1.0.3.1</version>
</dependency>
下面以一个完整的例子（aka-dbutils-spring-boot-starter-test）来介绍如何与Spring集成。
例子工程(aka-dbutils-spring-boot-starter-test)的maven配置如下：
<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>
<artifactId>aka-dbutils-spring-boot-starter-test</artifactId>
<groupId>com.github.ulwx</groupId>
<version>1.0.3.1-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.4.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<artifactId>aka-dbutils-spring-boot-starter</artifactId>
<groupId>com.github.ulwx</groupId>
<version>1.0.3.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-dbcp2</artifactId>
<version>2.8.0</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.23</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.4.4</version>
</plugin>
</plugins>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.*</include>
</includes>
<filtering>false</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.md</include>
<include>**/*.xml</include>
<include>**/*.properties</include>
<include>**/*.sql</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
<testResources>
<testResource>
<directory>src/test/resources</directory>
<includes>
<include>**/*.*</include>
</includes>
<filtering>false</filtering>
</testResource>
<testResource>
<directory>src/test/java</directory>
<includes>
<include>**/*.md</include>
<include>**/*.xml</include>
<include>**/*.sql</include>
<include>**/*.properties</include>
</includes>
<filtering>false</filtering>
</testResource>
</testResources>
</build>
</project>
例子工程目录如下：
下面为MyConfiguration配置类，用于声明数据源及事务相关的配置。
package com.github.ulwx.aka.dbutils.database.spring.boot.starter.test;
import com.github.ulwx.aka.dbutils.database.spring.AkaMpperScannerConfigurer;
import com.github.ulwx.aka.dbutils.database.spring.MDataBaseFactory;
import com.github.ulwx.aka.dbutils.database.spring.MDataBaseTemplate;
import com.github.ulwx.aka.dbutils.database.utils.DbConst;
import org.apache.commons.dbcp2.BasicDataSource;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@EnableTransactionManagement(proxyTargetClass = true)
@EnableAspectJAutoProxy(exposeProxy = true)
@Configuration
@ComponentScan
public class MyConfiguration implements ApplicationContextAware {
private ApplicationContext ctx;
@Bean(destroyMethod = "close")
public BasicDataSource dataSource() {
BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/test?x=1&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8&useSSL=false");
dataSource.setUsername("root");
dataSource.setPassword("abcd");
dataSource.setMaxWaitMillis(10000);
dataSource.setInitialSize(1);
dataSource.setMaxTotal(10);
dataSource.setMinEvictableIdleTimeMillis(6000);
return dataSource;
}
@Bean
public DataSourceTransactionManager transactionManager() {
DataSourceTransactionManager dt = new DataSourceTransactionManager();
dt.setDataSource(dataSource());//①
return dt;
}
//配置MDataBaseTemplate类型Bean，如果不配置，aka-dbutils-spring-boot-starter会自动配置一个
@Bean
public MDataBaseFactory mDataBaseFactory() {
MDataBaseFactory mDataBaseFactory = new MDataBaseFactory(dataSource());//② 和①处的必须注入同一个连接池
mDataBaseFactory.setTableColumRule(DbConst.TableNameRules.underline_to_camel);
mDataBaseFactory.setTableNameRule(DbConst.TableColumRules.underline_to_camel);
return mDataBaseFactory;
}
@Bean
//配置MDataBaseTemplate Bean用于数据库操作，如果不配置，aka-dbutils-spring-boot-starter会自动配置一个
public MDataBaseTemplate mDataBaseTemplate() {
MDataBaseFactory mDataBaseFactory=mDataBaseFactory();
return new MDataBaseTemplate(mDataBaseFactory);
}
@Bean
//配置AkaMpperScannerConfigurer Bean用于用于扫描Mapper映射器（继承自AkaMapper）从而生成代理Bean注册到Spring容器
//如果不配置,aka-dbutils-spring-boot-starter会自动配置一个
public static AkaMpperScannerConfigurer akaMpperScannerConfigurer(){
AkaMpperScannerConfigurer akaMpperScannerConfigurer=
new AkaMpperScannerConfigurer();
akaMpperScannerConfigurer.setBasePackage(MyConfiguration.class.getPackage().getName());
//如果不指定，默认使用"mDataBaseTemplate"名称
//akaMpperScannerConfigurer.setMdDataBaseTemplateBeanName("mDataBaseTemplate");
return akaMpperScannerConfigurer;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.ctx=applicationContext;
}
}
在SpringBoot里使用aka-dbutils功能需要配置MDataBaseFactory Bean，MDataBaseTemplate Bean和AkaMpperScannerConfigurer Bean，如果你不配置，aka-dbutils-spring-boot-starter会帮你自动配置它们。AkaMpperScannerConfigurer Bean用于扫描Mapper映射器（需要继承自AkaMapper），从而生成Mapper映射器的动态代理Bean并注册到Spring容器，这样Service可以直接通过声明Mapper映射器来注入动态代理Bean。每个Mappe映射器会对应一个同名的md文件放在相同目录下，Mapper映射器里的方法对应md文件里的md方法。
Address类
package com.github.ulwx.aka.dbutils.database.spring.boot.starter.test;
import com.github.ulwx.aka.dbutils.database.MdbOptions;
import com.github.ulwx.aka.dbutils.tool.support.ObjectUtils;
public class Address extends MdbOptions implements java.io.Serializable {
private String name;/*;len:20*/
private Integer addressId;/*;len:10*/
private Long custormerId;/*;len:19*/
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAddressId(Integer addressId){
this.addressId = addressId;
}
public Integer getAddressId(){
return addressId;
}
public void setCustormerId(Long custormerId){
this.custormerId = custormerId;
}
public Long getCustormerId(){
return custormerId;
}
public String toString(){
return ObjectUtils.toString(this);
}
private static final long serialVersionUID =556120941L;
}
AddressDao类
package com.github.ulwx.aka.dbutils.database.spring.boot.starter.test;
import com.github.ulwx.aka.dbutils.database.spring.MDataBaseTemplate;
import com.github.ulwx.aka.dbutils.tool.MD;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Component
public class AddressDao {
private MDataBaseTemplate mDataBaseTemplate; //使用MDataBaseTemplate Bean操作数据库
public AddressDao(MDataBaseTemplate mDataBaseTemplate){
this.mDataBaseTemplate=mDataBaseTemplate;
}
public List<Address> getListMd(){
Map<String, Object> mp=new HashMap<>();
List<Address> list=mDataBaseTemplate.queryList(Address.class,
MD.md(),mp);
return list;
}
public void updateMd0(){
Map<String, Object> mp=new HashMap<>();
mDataBaseTemplate.update(MD.md(),mp);
}
@Transactional(propagation = Propagation.REQUIRED)
public void updateMd1(){
Map<String, Object> mp=new HashMap<>();
mDataBaseTemplate.update(MD.md(),mp);
}
}
///AddressDao对应的md文件（AddressDao.md）的内容
getListMd
===
select * from address
updateMd0
===
UPDATE
`address`
SET
`name` = CONCAT('',now())
WHERE `address_id` = 0
updateMd1
===
UPDATE
`address`
SET
`name` = CONCAT('',now())
WHERE `address_id` = 1
AddressMapper类（Mapper映射器）
package com.github.ulwx.aka.dbutils.database.spring.boot.starter.test;
import com.github.ulwx.aka.dbutils.database.AkaMapper;
public abstract class AddressMapper extends AkaMapper {
public abstract void updateMd();
public void update(){
this.updateMd(); //可以调用其它抽象方法
}
public void query(){
//可以在方法内部this.getMdDataBase()获取MDataBase示例从而进行数据库操作
Address address=new Address();
address.setAddressId(1);
this.getMdDataBase().queryOneBy(address);
}
}
//AddressMapper对应的md文件（AddressMapper.md）的内容
updateMd
===
UPDATE
`address`
SET
`name` = CONCAT('',now())
WHERE `address_id` = 0
MyService类
package com.github.ulwx.aka.dbutils.database.spring.boot.starter.test;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Service
public class MyService {
private AddressDao addressDao;
private AddressMapper mapper; //使用Mapper映射器操作数据库
public MyService(AddressDao addressDao,AddressMapper mapper) {
this.addressDao = addressDao;
this.mapper=mapper;
}
@Transactional(propagation = Propagation.REQUIRED)
public void updateMdb(){
List<Address> list2= addressDao.getListMd();
//声明了Propagation.NESTED事务
addressDao.updateMd0();
try {
addressDao.updateMd1();
}catch (Exception e){
e.printStackTrace();
}
//MyService方法的内部之间的调用会使被调用方法上声明的事务失效，所以需要用下面方式调用
((MyService) AopContext.currentProxy()).updateMdbOther();
//MyService方法的内部调用会使被调用方法上声明的事务失效，下面的内部调用 updateMdbOther()的运行处于updateMdb()方法的事务里。
// updateMdbOther();
int i=0;
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void updateMdbOther(){
System.out.println("call updateMdbOther");
}
@Transactional(propagation = Propagation.REQUIRED)
public void testMapper(){
//testMapper()方法处于事务里，testMapper()方法里所有调用的方法在整个事务里只会用到一个数据库连接，testMapper()方法退出后
//数据库连接关闭
mapper.updateMd(); //使用的数据库连接在testMapper()进入时会被创建，updateMd()调用完后，数据库连接不会关闭
mapper.update(); //使用的数据库连接在testMapper()进入时会被创建，update()调用完后，数据库连接不会关闭
mapper.query();//使用的数据库连接在testMapper()进入时会被创建，query()调用完后，数据库连接不会关闭
}
}
TestApplication类
package com.github.ulwx.aka.dbutils.database.spring.boot.starter.test;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class TestApplication {
public static void main(String[] args) {
SpringApplication application = new SpringApplication(TestApplication.class);
application.run(args);;
}
@Bean
public ApplicationRunner runner(MyService myService){
return args -> {
myService.testMapper(); //testMapper()方法体运行在事务中
myService.updateMdb();//updateMdb()方法体运行在事务中
System.out.println("ok!");
};
}
}
至此与SpringBoot集成的例子介绍完毕，读者可以发现与MyBatis有很多相似之处。
关于本节的例子你可以到https://github.com/ulwx/aka-dbutils-spring-test下载。
扫一扫
828
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
