Groovy语言之SpringBoot整合JDBC案例

---

前言

Groovy是一种功能强大，可选类型和动态 语言，与静态打字和静态编译功能，支持Java平台旨在提高开发人员的生产力得益于简洁，熟悉且简单易学的语法。它可以与任何Java程序顺利集成，并立即为您的应用程序提供强大的功能，包括脚本编写功能，领域特定语言编写，运行时和编译时元编程以及函数式编程。

---

一、 Groovy火吗？

编程语言五月排行榜

二、Groovy的特点

Groovy中有以下特点:

• 同时支持静态和动态类型。
• 支持运算符重载。
• 本地语法列表和关联数组。
• 对正则表达式的本地支持。
• 各种标记语言，如XML和HTML原生支持。
• Groovy对于Java开发人员来说很简单，因为Java和Groovy的语法非常相似。
• 您可以使用现有的Java库。
• Groovy扩展了java.lang.Object。

三、使用步骤

首先我们先集成JDBC，再结合Groovy使用。

3.1 导入pom.xml依赖

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-jdbcartifactId>
dependency>
<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <scope>runtimescope>
dependency>

3.2 配置application.yml

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://192.168.31.158:3306/testjdbc?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.mysql.cj.jdbc.MysqlDataSource

3.3 编写API接口

User实体类:

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
     

    /**
     * 主键
     */
    private Integer id;
    /**
     * 账号
     */
    private String username;
    /**
     * 密码
     */
    private String password;
}

UserController控制器：

@RestController
@RequestMapping("/api")
public class UserController {
     

    @Autowired
    private UserService userService;

    @GetMapping("/findAll")
      public List<Map<String, Object>> findAll(){
     
        return userService.findAll();
    }
}

3.4 编写业务层

@Service
public class UserService {
     

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<Map<String, Object>> findAll() {
     
        List<Map<String, Object>> list = jdbcTemplate.queryForList("SELECT * FROM t_user");
        if (list.size() > 0) {
     
            return list;
        }
        return null;
    }
}

3.5 测试

http://localhost:8081/api/findAll

四、集成Groovy

4.1 导入pom.xml依赖

<dependency>
    <groupId>org.codehaus.groovygroupId>
    <artifactId>groovy-allartifactId>
    <version>3.0.7version>
    <type>pomtype>
dependency>

4.2 编写API接口

@RestController
@RequestMapping("/api")
public class UserController {
     

    @Autowired
    private UserService userService;
    @Autowired
    private UserGroovyService userGroovyService;

    @GetMapping("/findAll")
      public List<Map<String, Object>> findAll(){
     
        return userService.findAll();
    }

    @GetMapping("/list")
    public List<User> list(){
     
        return userGroovyService.list();
    }
}

此时注意看我们新的接口list，它的返回值就是一个List集合，泛型是User对象，此时我们创建一个GroovyService接口业务层。

4.3 编写业务层

@Service
class UserGroovyService {
     

    @Autowired
    private JdbcTemplate jdbcTemplate

    List<User> list() {
     
        return jdbcTemplate.queryForList("SELECT * FROM t_user") as List<User>
    }
}

仔细看jdbcTemplate.queryForList方法，我们查看一下他的源码：

它的返回值是一个List集合，泛型是一个map集合，按照之前我们jdbc的写法，那么我们们这个位置：

也要是这样的类型，否则就需要处理类型，但是我们使用Groovy语法，它就不需要，直接给我转换成我们想要的集合类型了。

4.4 测试

五、插入数据对比

5.1 Java的方式

@GetMapping("/jdbc-add")
public boolean add(){
     
    return userService.add();
}

public boolean add() {
     
    // 插入数据库
    Object[] args = new Object[]{
     "dt","123456"};
    int update = jdbcTemplate.update("INSERT INTO t_user(username, password) VALUES (?,?)", args);
    return update > 0;
}

5.2 Groovy的方式

@GetMapping("/groovy-add")
public boolean add1(){
     
    return userGroovyService.add();
}

boolean add() {
     
    def username = 'dt2'
    def passwpord = '123456'
   return jdbcTemplate.update("INSERT INTO t_user(username, password) VALUES (?,?)",username,passwpord )
}

六、Groovy基本语法

6.1 打印输出

class Example {
     

    static void main(String[] args) {
     
        println('Hello World')
        printf('Hello World')
    }
}

6.2 关键字

6.3 数据类型

6.4 变量

变量声明

class Example {
      
   static void main(String[] args) {
      
      // x is defined as a variable 
      String x = "Hello";
		
      // The value of the variable is printed to the console 
      println(x);
   }
}

定义变量
Groovy中支持动态类型，即定义变量的时候可以不指定其类型。Groovy中，变量定义可以使用关键字def。注意，虽然def不是必须的，但是为了代码清晰，建议还是使用def关键字

def a = 1 //定义一个整形

def b = "字符串" //定义一个字符串

def double c = 1.0  //定义一个 double 类型，也可以指定变量类型

定义函数

//无参函数
def fun1(){
     

}

//有参函数 , 无需指定参数类型  
def fun2( def1 , def2 ){
     

}

6.5 循环

使用…表示区间范围：

for (i in 0..5){
     
    println("hello world")
}

6.6 三目运算符

def name = 'd'
def result = name ?: "abc"
println (result)

6.7 捕获异常

try {
     
 println 5 / 0
} catch (anything) {
     
    println (anything)
}

6.8 switch

age = 36
def rate

switch (age) {
     
    case 10..26:
        rate = 0.05
        break
    case 27..36:
        rate = 0.06
        break
    case 37..46:
        rate = 0.07
        break
    default:
        throw new IllegalArgumentException()
}

println( rate)

6.9 数据类型转换

//String 转成 int 
def s2 = s1 as int

//String 转成 int 
def s3 = s1.asType(Integer)

6.10 对象转json 、 json 转对象

Person person = new Person();
person.name = "zhaoyanjun"
person.age = 27

//把对象转换为 json 字符串
def json =JsonOutput.toJson(person)

println(json)

JsonSlurper jsonSlurper = new JsonSlurper()

//把字符串转换为对象
Person person1 = jsonSlurper.parseText(json)

println( person1.name )

6.11 集合对象转json 、json 转集合对象

Person person = new Person();
person.name = "zhaoyanjun"
person.age = 27

Person person1 = new Person();
person1.name = "zhaoyanjun2"
person1.age = 28

def list = [person,person1]

//把集合对象转换为 json 字符串
def jsonArray =JsonOutput.toJson(list)

println(jsonArray)

JsonSlurper jsonSlurper = new JsonSlurper()

//把字符串转换为集合对象
List<Person> list2 = jsonSlurper.parseText(jsonArray)

println( list2.get(1).name )

总结

Groovy是一种动态语言，它和Java类似（算是Java的升级版，但是又具备脚本语言的特点），都在Java虚拟机中运行。当运行Groovy脚本时它会先被编译成Java类字节码，然后通过JVM虚拟机执行这个Java字节码类。