第一章：Groovy 简介
第二章：Groovy 安装
第三章：创建 Groovy 项目
第四章：Groovy 语法
第五章：在 IDEA 中创建普通的 Java 工程
第六章：在 IDEA 中创建 WEB 工程
- 6.1 在 IDEA 中创建 WEB 工程
- 6.2 框架的配置和业务代码
第七章：项目部署
- 7.1 部署到本地 Tomcat
第八章：Gradle 对测试的支持
- 8.1 Gradle 对 Junit 5 的支持
- 8.2 包含和排除特定的测试

第一章：Groovy 简介

在某种程序上，Groovy 可以被视为 Java 的一种脚本化改良版。
Groovy 也是运行在 JVM 上的，它可以很好的和 Java 代码及其相关库进行交互操作。
Groovy 是一种成熟的面向对象编程语言，既可以面向对象编程，也可以用作纯粹的脚本语言。
大多数有效的 Java 代码都可以转换为有效的 Groovy 代码。
Groovy 和 Java 的主要区别在于：完成同样的任务所需要的 Groovy 代码要比 Java 代码更少。
Groovy 的特点如下：
- ① 功能更为强大，例如：提供了动态类型转换、闭包和元编程支持。
- ② 支持函数式编程，不需要 main 函数。
- ③ 默认导入常用的包。
- ④ 类中不支持 default 作用域，默认的作用域是 public 。
- ⑤ Groovy 中基本类型也是对象，可以直接调用对象的方法。
- ⑥ 支持 DSL和其它简洁的语法，让代码变得易于阅读和维护。
- ⑦ Groovy 是基于 Java 语言的，所以完全兼容 Java 语法，对于 Java 程序员而言学习的成本低。

第二章：Groovy 安装

Groovy 的下载地址：https://groovy.apache.org/download.html （网速不行，请点这里apache-groovy-sdk-4.0.3.zip）。

解压并配置环境变量：

检测是否安装成功：

groovy -v

第三章：创建 Groovy 项目

使用 IDEA 创建 Groovy 项目。

第四章：Groovy 语法

4.1 Groovy 的基本语法

注意：

类型转换：当需要的时候，类型之间会自动发生类型转换，如：字符串（String）、基本类型（int）和类型的包装类（Integer）。
类说明：如果一个 groovy 文件没有任何类定义，它将被当做 script 来处理，也就意味着这个文件被透明的转换为一个 Script 类型的类，这个自动转换的类将使用原始的 groovy 文件名作为类的名字。groovy 文件的内容被打包进 run() 方法。另外在产生的类中将被加入一个 main 方法以便执行外部的脚本。

示例：
作为面向对象的方式 Actor.groovy ：

package com.github
class Actor {
    int age;
    String name;
    boolean sex;
}

翻译后的 Java 代码：

package com.github;
import groovy.lang.GroovyObject;
import groovy.lang.MetaClass;
import groovy.transform.Generated;
import groovy.transform.Internal;
import java.beans.Transient;
public class Actor implements GroovyObject {
    private int age;
    private String name;
    private boolean sex;
    @Generated
    public Actor() {
        MetaClass var1 = this.$getStaticMetaClass();
        this.metaClass = var1;
    }
    @Generated
    @Internal
    @Transient
    public MetaClass getMetaClass() {
        MetaClass var10000 = this.metaClass;
        if (var10000 != null) {
            return var10000;
        } else {
            this.metaClass = this.$getStaticMetaClass();
            return this.metaClass;
        }
    }
    @Generated
    @Internal
    public void setMetaClass(MetaClass var1) {
        this.metaClass = var1;
    }
    @Generated
    public int getAge() {
        return this.age;
    }
    @Generated
    public void setAge(int var1) {
        this.age = var1;
    }
    @Generated
    public String getName() {
        return this.name;
    }
    @Generated
    public void setName(String var1) {
        this.name = var1;
    }
    @Generated
    public boolean getSex() {
        return this.sex;
    }
    @Generated
    public boolean isSex() {
        return this.sex;
    }
    @Generated
    public void setSex(boolean var1) {
        this.sex = var1;
    }
}

示例：
作为脚本方式 Demo.groovy ：

package com.github
def name = '许大仙'
println name

翻译后的 Java 代码：

package com.github;
import groovy.lang.Binding;
import groovy.lang.Script;
import org.codehaus.groovy.runtime.InvokerHelper;
public class Demo extends Script {
    public Demo() {
    }
    public Demo(Binding context) {
        super(context);
    }
    public static void main(String... args) {
        InvokerHelper.class.invoke<invokedynamic>(InvokerHelper.class, Demo.class, args);
    }
    public Object run() {
        Object name = "许大仙";
        return this.invoke<invokedynamic>(this, name);
    }
}

4.2 Groovy 的常见注意点

① Groovy 中使用 def 定义属性、方法，def 支持动态类型声明。
示例：

package com.github
class Actor {
    def bookName = '诛仙';
    def description = '非常好看的仙侠小说';
}

② 在 Groovy 中注释分为单行注释和多行注释。
示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙';
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说';
}

③ 在 Groovy 中语句最后的 ; 是可以省略的。
示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
}

④ Groovy 可以自动的为使用 def 关键字修饰的属性生成 setter 和 getter 方法。
示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
}

package com.github
def actor = new Actor()
actor.setBookName('水浒传')
actor.setDescription('还行吧')
println(actor.getBookName())
println(actor.getDescription())

⑤ 方法声明的时候，参数类型、返回值类型、return 关键字都可以省略。方法调用的时候，在不引起歧义的情况下，可以省略 () 。
示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
    def sale(price){
        "${bookName} 的价格是 ${price}"
    }
}

package com.github
def actor = new Actor()
def price = actor.sale 50
println price

⑥ 变量易用：在不引起歧义的情况下，{} 也是可以省略的。
示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
    def sale(price){
        "$bookName 的价格是 $price"
    }
}

package com.github
def actor = new Actor()
def price = actor.sale 50
println price

⑦ 对象属性赋值：
- 方式1 ：对象.属性名 =
- 方式2：对象[“属性名”] =
- 方式3：对象.属性的 setter 方法()
- 方法4：具名构造器的形式。
示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
}

package com.github
def actor = new Actor()
actor.bookName = '水浒传'
actor.description = '还行吧'
println(actor.bookName + actor.description)

示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
}

package com.github
def actor = new Actor()
actor['bookName'] = '水浒传'
actor['description'] = '还行吧'
println(actor.bookName + actor.description)

示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
}

package com.github
def actor = new Actor()
actor.setBookName('水浒传')
actor.setDescription('还行吧')
println(actor.bookName + actor.description)

示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
}

package com.github
def actor = new Actor(bookName: '水浒传',description: '还行吧')
println(actor.bookName + actor.description)

⑧读取属性值：
- 方式1：对象.属性名。
- 方式2：对象[“属性名”] 。
- 方式3：对象.属性的 getter 方法()。
示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
}

package com.github
def actor = new Actor()
println(actor.bookName)
println(actor.description)

示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
}

package com.github
def actor = new Actor()
println(actor["bookName"])
println(actor["description"])

示例：

package com.github
class Actor {
    // 单号注释：小说的名称
    def bookName = '诛仙'
    /* 多行注释：小说的描述 */
    def description = '非常好看的仙侠小说'
}

package com.github
def actor = new Actor()
println(actor.getBookName())
println(actor.getDescription())

4.3 Groovy 中的字符串

单引号：不支持变量引用，不支持换行操作。
双引号：支持变量引用，不支持换行操作。
模板字符串：不支持变量应用，支持换行操作。
示例：

package com.github
def desc = '测试'
def str1 = '单引号，不支持变量引用，不支持换行操作 ${desc}'
println str1
def str2 = "双引号，支持变量引用，不支持换行操作 ${desc}"
println str2
def str3 = '''模板字符串，不支持变量引用，
                    支持换行操作 ${desc}
                    '''
println str3

4.3 Groovy 支持三语句结构

Groovy 支持顺序结构、分支结构（if-else、if-else-if、switch-case）和循环结构（while、do-while、for）。
示例：略。

4.4 Groovy 中的数据类型和权限修饰符

4.4.1 Groovy 中的数据类型

原生数据类型及包装类： | 原生数据类型 | 包装类 | | —- | —- | | boolean | Boolean | | char | Character | | short | Short | | int | Integer | | long | Long | | float | Float | | double | Double |

类、内部类、抽象类、接口。
注解。
Trait：带方法实现的接口。

4.4.2 权限修饰符

Groovy 中的权限修饰符：public 、protected 和 private 。

4.4.3 Groovy 中的类和 Java 中的类的区别

① 没有可见性修饰符的类或方法自动是 public 。
② 没有可见性修饰符的字段将自动转换为属性，不需要显示的定义 setter 和 getter 方法。
③ 如果属性声明为 final 的，则不会生成 setter 方法。
④ 一个源文件可能包含一个或多个类，但是如果一个文件中不包含类定义的代码，则默认视为脚本。脚本只是一些特殊约定的类，它们的名称和源文件相同，所以不要在脚本中包含和脚本源文件相同的类的定义。

4.5 Groovy 中的集合操作

Groovy 支持 List、Map 集合操作，并且拓展了 Java 中的 API 。
List 集合： | 方法名 | 说明 | | —- | —- | | add() | 添加某个元素 | | plus() | 添加某个 list 集合 | | remove() | 删除指定下标的元素 | | removeElement() | 删除某个指定的元素 | | removeAll() | 移除某个集合中的元素 | | pop() | 弹出 list 集合中最后一个元素 | | putAt() | 修改指定下标的元素 | | each() | 遍历 | | size() | 获取 list 列表中元素的个数 | | contains() | 判断列表中是否包含指定的值，则返回 true |

Map 集合： | 方法名 | 说明 | | —- | —- | | put() | 向 map 中添加元素 | | remove() | 根据某个键做移除，或者移除某个键值对 | | +、- | 支持 map 集合的加减操作 | | each() | 遍历 map 集合 |

注意：在 Groovy 中可以将不同类型的元素放入集合中。

示例：

package com.github
// --------------  List 的新增操作 ---------------
def list = [5, 6, 7, 8]
assert list instanceof List
list.add(12)
println list.size() // 5
def list2 = [1, 2, 3, 4]
println list.plus(list2) // [5, 6, 7, 8, 12, 1, 2, 3, 4]
// --------------  List 的删除操作 ---------------
// 删除指定下标的元素
list.remove(2)
println list // [5, 6, 8, 12]
// 删除集合中的指定元素
list.removeElement(12)
println list // [5, 6, 8]
// 删除集合中的最后一个元素
list.pop()
println list // [6, 8]
// --------------  List 的改操作 ---------------
list.putAt(1,10) // 等同于 list[1] = 10
println list // [6, 10]
// --------------  List 的查询操作 ---------------
list.each(it->{
    println it
})

4.6 Groovy 中的类导入

Groovy 遵循 Java 语言的 import 导入语法：

import groovy.xml.MarkupBuilder
def xml = new MarkupBuilder()
assert xml != null

Groovy 语言默认提供的导入：

import java.lang.* 
import java.util.* 
import java.io.* 
import java.net.* 
import groovy.lang.* 
import groovy.util.* 
import java.math.BigInteger 
import java.math.BigDecimal

这样做是因为这些包中的类最常用。通过导入这些样板代码减少了。

4.7 Groovy 中的异常处理

Groovy 中的异常处理和 Java 中的异常处理是一样的。
示例：

def z
try {
    def i = 7, j = 0
    try {
        def k = i / j
        assert false        //never reached due to Exception in previous line
    } finally {
        z = 'reached here'  //always executed even if Exception thrown
    }
} catch ( e ) {
    assert e in ArithmeticException
    assert z == 'reached here'
}

4.8 Groovy 中的闭包

闭包：Groovy 中的闭包是一个开放的、匿名的代码块，它可以接受参数、也可以有返回值。闭包可以引用其周围作用域中声明的变量。
语法：

{ [closureParameters -> ] statements }

调用：
- 第一步：将闭包赋值给一个变量。
- 第二步：变量名() 或变量名.call() 。

注意：闭包在实际开发中的使用就是作为方法的参数使用。

示例：

package com.github
def run = {
    println '开始。。。'
    println '结束。。。'
}
run()

示例：

package com.github
def run = {who ->
    println '开始。。。'
    println who
    println '结束。。。'
}
run('你爷爷')

示例：

package com.github
def run(Closure closure) {
    println 'closure ... 开始'
    closure()
    println 'closure ... 结束'
}
run({ ->
    println "我是谁"
})

示例：

package com.github
def calculate(num1, num2, Closure closure) {
    def result = closure(num1, num2)
    println result
}
calculate(1, 2, { k, v -> k + v })

示例：

package com.github
def calculate(num1, num2, Closure closure) {
    def result = closure(num1, num2)
    println result
}
calculate(1, 2){ k, v -> k + v }

示例：

package com.github
def calculate(Closure closure) {
    def num1 = 10
    def num2 = 20
    def result = closure(num1, num2)
    println result
}
calculate{ k, v -> k + v }

第五章：在 IDEA 中创建普通的 Java 工程

① 创建由 Gradle 管理的项目：

② 修改当前项目使用本地安装的 Gradle ，以便加快下载项目 jar 包的速度：

注意：操作图形化的 IDEA 使用的 Gradle 版本就是默认本地安装的 Gradle 版本了。

注意：终端中执行的 gradlew 开头的命令的 Gradle Wrapper 的版本是 IDEA 内置 Gradle 插件的版本。

注意：当我们在 build.gradle 中添加依赖之后，这些依赖会下载到 GRADLE_USER_HOME/caches/modules-2/files-2.1 目录下。

第六章：在 IDEA 中创建 WEB 工程

6.1 在 IDEA 中创建 WEB 工程

目前，IDEA 的版本是无法选择创建 WEB 工程的，需要我们手动在普通的 Java 工程的基础上进行修改。
① 在 build.gradle 文件中增加 war 插件，并导入相关的依赖。

plugins {
    id 'java'
    // 标识这个一个 war 工程
    id 'war'
}
group 'com.github'
version '1.0-SNAPSHOT'
repositories {
    mavenLocal()
    maven {
        url = "https://maven.aliyun.com/nexus/content/groups/public"
    }
    mavenCentral()
}
dependencies {
    implementation 'org.springframework:spring-beans:4.1.7.RELEASE'
    implementation 'org.springframework:spring-web:4.1.7.RELEASE'
    implementation 'org.springframework:spring-webmvc:4.1.7.RELEASE'
    implementation 'org.springframework:spring-tx:4.1.7.RELEASE'
    implementation 'org.springframework:spring-test:4.0.5.RELEASE'
    implementation 'org.springframework:spring-jdbc:4.1.7.RELEASE'
    implementation 'org.mybatis:mybatis-spring:1.2.3'
    implementation 'org.mybatis:mybatis:3.3.0'
    implementation 'mysql:mysql-connector-java:5.1.36'
    implementation 'com.alibaba:druid:1.0.15'
    implementation "com.fasterxml.jackson.core:jackson-databind:2.2.3"
    implementation "com.fasterxml.jackson.core:jackson-annotations:2.2.3"
    implementation "com.fasterxml.jackson.core:jackson-core:2.2.3"
    implementation 'org.aspectj:aspectjweaver:1.8.6'
    implementation 'log4j:log4j:1.2.17'
    implementation 'org.slf4j:slf4j-api:1.7.25'
    implementation 'jstl:jstl:1.2'
    compileOnly 'javax.servlet:servlet-api:2.5'
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}
test {
    useJUnitPlatform()
}

② 需要在 src/main 目录下创建 webapp/WEB-INF/web.xml 文件以及页面，并配置框架的配置以及业务代码。

6.2 框架的配置和业务代码

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
        http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <context-param>
        <!-- 指定spring 配置文件的路径和名称 -->
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!-- 指定spring的监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!-- 2.配置springmvc的前端控制器 -->
    <servlet>
        <servlet-name>DispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!-- 2.处理POST请求乱码的过滤器 -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- 3.配置将POST请求转换为PUT或者DELETE请求的过滤器 -->
    <filter>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

springmvc.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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

      <!-- 1.配置扫描包 -->
    <context:component-scan base-package="com.github" use-default-filters="false">
         <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
         <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
    </context:component-scan>

     <!-- 2.配置内部资源视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
    <!--3.处理静态资源文件 -->
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>
</beans>

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

</configuration>

jdbc.properites

jdbc.jdbcUrl=jdbc:mysql://localhost:3306/test?rewriteBatchedStatements=true
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.userName=root
jdbc.password=123456

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"
       xmlns:context="http://www.springframework.org/schema/context" 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/tx http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!-- 0.配置扫描包 -->
    <context:component-scan base-package="com.github">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>
    </context:component-scan>

    <!-- 1.加载properties文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>


    <!-- 2.配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.userName}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="url" value="${jdbc.jdbcUrl}"></property>
        <property name="driverClassName" value="${jdbc.driverClass}"></property>
    </bean>

    <!-- 4.配置数据源事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

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


    <!-- 1.配置spring整合mybatis -->
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    </bean>

    <!-- 2.配置扫描mapper接口的bean对象 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.github.dao"/>
    </bean>

</beans>

com/github/dao/AdminMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.github.dao.AdminMapper">

    <select id="getAdminList" resultType="com.github.bean.Admin">
        select id,username,email from admin
    </select>

</mapper>

Admin.java

package com.github.bean;

public class Admin {
    private Integer id;
    private String username;
    private String email;

    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 String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "Admin{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", email='" + email + '\'' +
                '}';
    }
}

AdminMapper.java

package com.github.dao;


import com.github.bean.Admin;

import java.util.List;

public interface AdminMapper {
    List<Admin> getAdminList();
}

AdminService.java

package com.github.service;

import com.github.bean.Admin;
import com.github.dao.AdminMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class AdminService {

    @Autowired
    private AdminMapper adminMapper;

    @Transactional
    public List<Admin> getAdminList(){
        return adminMapper.getAdminList();
    }
}

AdminController.java

package com.github.controller;

import com.github.bean.Admin;
import com.github.service.AdminService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
@RequestMapping("/admin")
public class AdminController {

    @Autowired
    private AdminService adminService;

    @RequestMapping("/list")
    @ResponseBody
    public List<Admin> getAdminList() {
        System.out.println("dada");
        return adminService.getAdminList();
    }

}

第七章：项目部署

7.1 部署到本地 Tomcat

第八章：Gradle 对测试的支持

8.1 Gradle 对 Junit 5 的支持

目前的版本，默认支持 Junit 5 ，build.gradle 配置如下：

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}

test {
    useJUnitPlatform()
}

我们只需要在含有 build.gradle 的目录下执行 gradle test 命令，gradle 就会帮助我们执行所有加了 @Test 注解的单元测试，并生成单元测试报告。

8.2 包含和排除特定的测试

Gradle 可以在 Junit 中的批量测试，设置包含或排除某些特定的测试，只需要在 build.gradle 文件中配置如下信息：

test {
    enabled true
    useJUnitPlatform()
    include 'com/**'
    exclude 'com/abc/**'
}

Java学科

Gradle 和 IDEA 的整合

第一章：Groovy 简介

第二章：Groovy 安装

第三章：创建 Groovy 项目

第四章：Groovy 语法

4.1 Groovy 的基本语法

4.2 Groovy 的常见注意点

4.3 Groovy 中的字符串

4.3 Groovy 支持三语句结构

4.4 Groovy 中的数据类型和权限修饰符

4.4.1 Groovy 中的数据类型

4.4.2 权限修饰符

4.4.3 Groovy 中的类和 Java 中的类的区别

4.5 Groovy 中的集合操作

4.6 Groovy 中的类导入

4.7 Groovy 中的异常处理

4.8 Groovy 中的闭包

第五章：在 IDEA 中创建普通的 Java 工程

第六章：在 IDEA 中创建 WEB 工程

6.1 在 IDEA 中创建 WEB 工程

6.2 框架的配置和业务代码

第七章：项目部署

7.1 部署到本地 Tomcat

第八章：Gradle 对测试的支持

8.1 Gradle 对 Junit 5 的支持

8.2 包含和排除特定的测试