SpringBoot Unofficial Tutorial | Part 5: Springboot integrates beatlsql

directory (?)[+]

Please indicate the source for reprinting:
http://blog.csdn.net/forezp/article/details/70662983
This article is from Fang Zhipeng's blog

BeetSql is a full-featured DAO tool with the advantages of Hibernate & Mybatis. It is suitable for applications that recognize SQL as the center and require tools that can automatically generate a large number of commonly used SQL.

advantages of beatlsql

Development efficiency
- No need for annotations, automatically use a large number of built-in SQL, easily complete the function of adding, deleting, modifying and querying, saving 50% of the development workload
- The data model supports Pojo, fast model such as Map/List, and hybrid model.
- SQL templates are implemented based on Beetl, which is easier to write and debug, and to extend
maintainability
- SQL is managed centrally in a more concise way and in Markdown mode, which is convenient for program development and database SQL debugging.
- Can automatically map sql files to dao interface classes
- Flexible and intuitive support supports one-to-one, one-to-many, and many-to-many relationship mapping without introducing complex OR Mapping concepts and techniques.
- With Interceptor function, you can debug, perform performance diagnosis of SQL, and extend other functions
other
- Built-in open source tools that support master-slave database support
- Supports cross-database platforms, and the work required by developers is reduced to a minimum. Currently, cross-database supports mysql, postgres, oracle, sqlserver, h2, sqllite, DB2.

import dependencies


<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.ibeetl</groupId>
            <artifactId>beetl</artifactId>
            <version>2.3.2</version>

        </dependency>

        <dependency>
            <groupId>com.ibeetl</groupId>
            <artifactId>beetlsql</artifactId>
            <version>2.3.1</version>

        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.0.5</version>
        </dependency>

All these dependencies are required.

integration stage

Since springboot does not have a quick start assembly for beatlsql, I need to import related beans myself, including data sources, package scans, transaction managers, etc.

Add the following code to the application:


@Bean(initMethod = "init", name = "beetlConfig")
    public BeetlGroupUtilConfiguration getBeetlGroupUtilConfiguration() {
        BeetlGroupUtilConfiguration beetlGroupUtilConfiguration = new BeetlGroupUtilConfiguration();
        ResourcePatternResolver patternResolver = ResourcePatternUtils.getResourcePatternResolver(new DefaultResourceLoader());
        try {
            // WebAppResourceLoader 配置root路径是关键
            WebAppResourceLoader webAppResourceLoader = new WebAppResourceLoader(patternResolver.getResource("classpath:/templates").getFile().getPath());
            beetlGroupUtilConfiguration.setResourceLoader(webAppResourceLoader);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //读取配置文件信息
        return beetlGroupUtilConfiguration;

    }

    @Bean(name = "beetlViewResolver")
    public BeetlSpringViewResolver getBeetlSpringViewResolver(@Qualifier("beetlConfig") BeetlGroupUtilConfiguration beetlGroupUtilConfiguration) {
        BeetlSpringViewResolver beetlSpringViewResolver = new BeetlSpringViewResolver();
        beetlSpringViewResolver.setContentType("text/html;charset=UTF-8");
        beetlSpringViewResolver.setOrder(0);
        beetlSpringViewResolver.setConfig(beetlGroupUtilConfiguration);
        return beetlSpringViewResolver;
    }

    //配置包扫描
    @Bean(name = "beetlSqlScannerConfigurer")
    public BeetlSqlScannerConfigurer getBeetlSqlScannerConfigurer() {
        BeetlSqlScannerConfigurer conf = new BeetlSqlScannerConfigurer();
        conf.setBasePackage("com.forezp.dao");
        conf.setDaoSuffix("Dao");
        conf.setSqlManagerFactoryBeanName("sqlManagerFactoryBean");
        return conf;
    }

    @Bean(name = "sqlManagerFactoryBean")
    @Primary
    public SqlManagerFactoryBean getSqlManagerFactoryBean(@Qualifier("datasource") DataSource datasource) {
        SqlManagerFactoryBean factory = new SqlManagerFactoryBean();

        BeetlSqlDataSource source = new BeetlSqlDataSource();
        source.setMasterSource(datasource);
        factory.setCs(source);
        factory.setDbStyle(new MySqlStyle());
        factory.setInterceptors(new Interceptor[]{new DebugInterceptor()});
        factory.setNc(new UnderlinedNameConversion());//开启驼峰
        factory.setSqlLoader(new ClasspathLoader("/sql"));//sql文件路径
        return factory;
    }


    //配置数据库
    @Bean(name = "datasource")
    public DataSource getDataSource() {
        return DataSourceBuilder.create().url("jdbc:mysql://127.0.0.1:3306/test").username("root").password("123456").build();
    }

    //开启事务
    @Bean(name = "txManager")
    public DataSourceTransactionManager getDataSourceTransactionManager(@Qualifier("datasource") DataSource datasource) {
        DataSourceTransactionManager dsm = new DataSourceTransactionManager();
        dsm.setDataSource(datasource);
        return dsm;
    }

Under the resouces package, add the META_INF folder, and add spring-devtools.properties to the folder:

restart.include.beetl=/beetl-2.3.2.jar
restart.include.beetlsql=/beetlsql-2.3.1.jar

Add an index.btl file under templates.

After adding the jar and configuring the beans of beatlsql, and the configuration of resources, springboot can access the database class.

Give a restful chestnut

Initialize the tables of the database

# DROP TABLE `account` IF EXISTS
CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  `money` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
INSERT INTO `account` VALUES ('1', 'aaa', '1000');
INSERT INTO `account` VALUES ('2', 'bbb', '1000');
INSERT INTO `account` VALUES ('3', 'ccc', '1000');

bean

public class Account {
    private int id ;
    private String name ;
    private double money;

    getter...

    setter...

  }

Data access dao layer

public interface AccountDao extends BaseMapper<Account> {

    @SqlStatement(params = "name")
    Account selectAccountByName(String name);
}

The interface inherits BaseMapper, and you can get some properties of single-table query. When you need to customize sql, you only need to write the file under the resouses/sql/account.md file:


selectAccountByName
===
*根据name获account

    select * from account where name= #name#

Among them, "===" above is the unique identifier, corresponding to the method name of the interface, "*" is followed by a comment, and the following is the custom sql statement, see the official documentation for details.

web tier

The service layer is omitted here, and the actual development is supplemented.


@RestController
@RequestMapping("/account")
public class AccountController {

    @Autowired
    AccountDao accountDao;

    @RequestMapping(value = "/list",method = RequestMethod.GET)
    public  List<Account> getAccounts(){
       return accountDao.all();
    }

    @RequestMapping(value = "/{id}",method = RequestMethod.GET)
    public  Account getAccountById(@PathVariable("id") int id){
        return accountDao.unique(id);
    }

    @RequestMapping(value = "",method = RequestMethod.GET)
    public  Account getAccountById(@RequestParam("name") String name){
        return accountDao.selectAccountByName(name);
    }

    @RequestMapping(value = "/{id}",method = RequestMethod.PUT)
    public  String updateAccount(@PathVariable("id")int id , @RequestParam(value = "name",required = true)String name,
    @RequestParam(value = "money" ,required = true)double money){
        Account account=new Account();
        account.setMoney(money);
        account.setName(name);
        account.setId(id);
        int t=accountDao.updateById(account);
        if(t==1){
            return account.toString();
        }else {
            return "fail";
        }
    }

    @RequestMapping(value = "",method = RequestMethod.POST)
    public  String postAccount( @RequestParam(value = "name")String name,
                                 @RequestParam(value = "money" )double money) {
        Account account = new Account();
        account.setMoney(money);
        account.setName(name);
        KeyHolder t = accountDao.insertReturnKey(account);
        if (t.getInt() > 0) {
            return account.toString();
        } else {
            return "fail";
        }
    }
}

Through the postman test, the code has all passed.

Personal experience, using bealsql to do some project experiments, but not really used in the real production environment, it is very cool to use. However, springboot does not provide direct support for autowiring, and you need to annotate beans yourself. In addition, there are not many people who use this orm, and I don't know if there are any pits. I didn't encounter any problems in the process of using it. In addition, its Chinese documentation is friendly.

Source code download: https://github.com/forezp/SpringBootLearning

References

BeetlSQL2.8 Chinese Documentation

Excellent article recommendation:

More springboot tutorials: springBoot unofficial tutorial | Article summary
More springcoud tutorials: The easiest SpringCloud tutorial ever | Article summary