Java 多线程之常见方法

Thread.currentThread() 方法

Thread.currentThread() 方法可以返回调用当前代码块的线程的信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class CustomThread extends Thread {

	public CustomThread() {
		super();
		System.out.println("构造方法：" + Thread.currentThread().getName());
	}

	@Override
	public synchronized void run() {
		super.run();
		System.out.println("run() 方法：" + Thread.currentThread().getName());
	}

}

1
2
3
4
5
6
7
public class CustomThreadTest {

	public static void main(String[] args) {
		CustomThread customThread = new CustomThread();
		customThread.start();
	}
}

Thread.currentThread() 方法可以返回是什么线程调用了CustomThread的构造方法，什么线程调用了CustomThread的run()方法：

1
2
构造方法：main
run() 方法：Thread-0

main 线程调用了CustomThread的构造方法，一个名叫Thread-0的线程调用了CustomThread的run()方法（若线程没有指定名称，则会默认生成一个名称）

Thread.currentThread().getName() 方法与 this.getName() 方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class CustomThread extends Thread {

	public CustomThread() {
		super();
		System.out.println("构造方法：" + Thread.currentThread().getName());
		System.out.println("构造方法：" + this.getName());
	}

	@Override
	public synchronized void run() {
		super.run();
		System.out.println("run() 方法：" + Thread.currentThread().getName());
		System.out.println("run() 方法：" + this.getName());
	}

}
1
2
3
4
5
6
7
public class CustomThreadTest {

	public static void main(String[] args) {
		CustomThread customThread = new CustomThread();
		customThread.start();
	}
}

输出：

1
2
3
4
构造方法：main
构造方法：Thread-0
run() 方法：Thread-0
run() 方法：Thread-0

可以发现this.getName() 方法两个结果是一样的，因为this实际是指代当前被调用的类实例是哪个：
当构造方法被调用时，main线程调用了CustomThread类实例，当run()方法被调用时，Thread-0 线程调用了CustomThead类实例

isAlive() 方法

isAlive() 方法可以判断当前的线程是否处于活动状态。

1
2
3
4
5
6
7
8
9
public class CustomThread extends Thread {

	@Override
	public synchronized void run() {
		super.run();
		System.out.println("run() 方法：" + this.isAlive());
	}

}

1
2
3
4
5
6
7
8
9
public class CustomThreadTest {

	public static void main(String[] args) {
		CustomThread customThread = new CustomThread();
		System.out.println("before start：" + customThread.isAlive());
		customThread.start();
		System.out.println("before end：" + customThread.isAlive());
	}
}

输出：

1
2
3
before start：false
before end：true
run() 方法：true

若调用 main 线程调用customThread 执行 start() 方法后休眠一会：

1
2
3
4
5
6
7
8
9
10
public class CustomThreadTest {

	public static void main(String[] args) throws InterruptedException {
		CustomThread customThread = new CustomThread();
		System.out.println("before start：" + customThread.isAlive());
		customThread.start();
		Thread.sleep(1000);
		System.out.println("before end：" + customThread.isAlive());
	}
}

输出：

1
2
3
before start：false
run() 方法：true
before end：false

因为经过休眠，customThread 线程已经执行完毕了

sleep() 方法

sleep() 方法的作用是在指定的毫秒数内让当前正在执行的线程休眠。
可参考上述例子。

getId() 方法

获取线程的唯一标识

setName() 方法

设置线程的名称

getName() 方法

获取线程的名称

展开全文 >>

Java 多线程之实例变量与线程安全

一个自定义的线程类，其也是一个普通的类，不同的使用方式，其实例变量对调用其的线程来说存在共享和不共享的情形。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class CustomThread extends Thread {

	private int count = 3;

	public CustomThread() {
		super();
	}

	@Override
	public void run() {
		super.run();
		while (count > 0) {
			System.out.println(this.currentThread().getId() + " 计算，count=" + count);
            count--;
		}
	}

}

不共享的情形

不共享实例变量的情形是创建多个自定义线程类的实例：

1
2
3
4
5
6
7
8
9
10
11
public class CustomThreadTest {

	public static void main(String[] args) {
		CustomThread customThreadA = new CustomThread();
		CustomThread customThreadB = new CustomThread();
		CustomThread customThreadC = new CustomThread();
		customThreadA.start();
		customThreadB.start();
		customThreadC.start();
	}
}

结果可能：

1
2
3
4
5
6
7
8
9
11 计算，count=3
11 计算，count=2
11 计算，count=1
12 计算，count=3
12 计算，count=2
12 计算，count=1
13 计算，count=3
13 计算，count=2
13 计算，count=1

结果可能：

1
2
3
4
5
6
7
8
9
11 计算，count=3
13 计算，count=3
12 计算，count=3
13 计算，count=2
12 计算，count=2
13 计算，count=1
12 计算，count=1
11 计算，count=2
11 计算，count=1

虽然由于线程执行顺序的随机性，但是每个线程实例均各自计算各自的实例变量 count

共享的情形

共享实例变量的情形是创建一个自定义线程类的实例，然后多个其他线程实例调用自定义线程类实例（此时自定义线程类相当于一个普通的类）：

1
2
3
4
5
6
7
8
9
10
11
12
public class CustomThreadTest {

	public static void main(String[] args) {
		CustomThread customThread = new CustomThread();
		Thread threadA = new Thread(customThread);
		Thread threadB = new Thread(customThread);
		Thread threadC = new Thread(customThread);
		threadA.start();
		threadB.start();
		threadC.start();
	}
}

结果可能：

1
2
3
4
12 计算，count=3
13 计算，count=3
12 计算，count=2
13 计算，count=1

结果可能：

1
2
3
4
5
12 计算，count=3
14 计算，count=3
13 计算，count=3
14 计算，count=1
12 计算，count=2

结果可能：

1
2
3
4
5
13 计算，count=3
13 计算，count=2
13 计算，count=1
14 计算，count=3
12 计算，count=-1

虽然由于线程执行顺序的随机性，但是每个线程实例均计算了 CustomThread 实例 customThread 的实例变量 count。
而且上述结果，看起来非常奇怪，与期望的相差甚远！这就是线程安全问题！

以上述例子为例，某些 JVM 中，i– 实际是三步操作：
1）获取原 i 值
2）计算 i-1
3) 对 i 进行赋值

正是因为分步操作，可能在执行完第一步以后，线程执行就会切换，导致执行结果千奇百怪，和期望不符。

若想解决线程安全问题，则需要执行线程同步策略。

synchronized 关键字修改线程内的方法，可以使其即使被多个线程调用，其也是按顺序执行，从而保证线程安全。
使用 synchronized 关键字修饰 run() 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class CustomThread extends Thread {

	private int count = 3;

	public CustomThread() {
		super();
	}

	@Override
	public synchronized void run() {
		super.run();
		while (count > 0) {
			System.out.println(this.currentThread().getId() + " 计算，count=" + count);
			count--;
		}
	}

}

结果可能是：

1
2
3
12 计算，count=3
12 计算，count=2
12 计算，count=1

结果可能是:

1
2
3
14 计算，count=3
14 计算，count=2
14 计算，count=1

执行结果只是因为线程执行的随机而不同，但是计算过程是与期望一致的：count 计算三次

展开全文 >>

Java 多线程基础

进程与线程

借鉴维基百科中的解释：

进程

进程（Process），是计算机中已运行程序的实体。
在面向进程设计的系统，进程是程序的基本执行实体；而在面向线程设计的系统（当今多数操作系统）中，进程本身不是基本运行单位，而是线程的容器。
程序本身只是指令、数据及其组织形式的描述，进程才是程序（指令和数据）的真正运行实例。
若干进程有可能与同一个程序相关系，且每个进程皆可以同步或异步的方式独立运行。
现代计算机系统可在同一时段时间内以进程的形式将多个程序加载到内存中，并借由时间共享，以在一个处理器上表现出同时运行的感觉。
使用多线程技术的操作系统或计算机结构，同样程序的平行线程，可在多CPU主机或网络上真正同时运行。

线程

线程（Thread），是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运行单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈（call stack），自己的寄存器环境（register context），自己的线程本地存储（thread-local storage）。
一个进程可以有很多线程，每条线程并行执行不同的任务。
在多核或多CPU，或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见，即提高了程序的执行吞吐率。在单CPU单核的计算机上，使用多线程技术，也可以把进程中负责IO处理、人机交互而常被阻塞的部分与密集计算的部分分开来执行，编写专门的workhorse线程执行密集计算，从而提高了程序的执行效率。

自定义 Java 线程

在 Java 的 JDK 开发包中，已经自带了对多线程技术的支持，可以很方便地进行多线程编程。实现多线程编程的方式主要有两种：

  • 继承 Thread 类
  • 实现 Runnable 接口
继承 Thread 类

Java 提供 Thread 类，自定义线程只需要继承自 Thread ，并且重写 run 方法即可：

1
2
3
4
5
6
7
8
9
public class CustomThread extends Thread {

	@Override
	public void run() {
		super.run();
		System.out.printf("通过继承 Thread 类自定义线程");
	}

}

使用自定义的线程类：

1
2
3
4
5
6
7
8
public class CustomThreadTest {

	public static void main(String[] args) {
		CustomThread customThread = new CustomThread();
		customThread.start();
		System.out.println("运行自定义线程结束");
	}
}

实现 Runnable 接口

Java 提供 Runnable 接口，自定义线程只需要实现 Runnable ，并且实现 run 方法即可：

1
2
3
4
5
6
public class CustomRunnable implements Runnable {

	public void run() {
		System.out.printf("通过实现 Runnable 接口自定义线程");
	}
}

使用自定义的线程类：

1
2
3
4
5
6
7
8
9
public class CustomRunnableTest {

	public static void main(String[] args) {
		CustomRunnable customRunnable = new CustomRunnable();
		Thread thread = new Thread(customRunnable);
		thread.start();
		System.out.println("运行自定义线程结束");
	}
}

两者在使用时有些许差别，通过实现 Runnable 接口的线程类使用时需要通过 Thread 类。而通过继承 Thread 类的线程类使用时不需要通过 Thread 类。
因为 Thread 已经实现了 Runnable 接口：

1
public class Thread implements Runnable

Thread 类有两个常用的构造函数：

1
2
3
4
5
6
7
8
 public Thread() {
    init(null, null, "Thread-" + nextThreadNum(), 0);
}


public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

其分别对应了上述两种情形。
因为 Java 单继承的局限性，在实际使用中，优先推荐通过实现 Runnable 接口自定义线程。

线程运行随机性

运行上述自定义线程，其输出结果可能是：

1
2
运行自定义线程结束
自定义线程

可能是：

1
2
自定义线程
运行自定义线程结束

一个线程的运行依赖其被其他线程调用 start()方法，start() 方法调用线程内的 run() 方法（如果直接调用 run() 方法其和普通的 Java 类没有任何区别）。Java 应用程序最少也会有一个运行 main() 方法的线程，称为主线程。
上述运行结果中: “运行自定义线程结束”即主线程调用执行 main() 方法后，main() 方法输出的信息，”自定义线程”即主线程调用自定义线程的 start() 方法后，自定义线程 start() 方法调用其 run() 方法后，run() 方法输出的信息。
之所以出现上述情况，是因为线程作为操作系统运行的最小单位，CPU 以分时共享的方式调用，其调用是不确定的。

展开全文 >>

SpringBoot 集成 Spring Security

JDK: 1.8

SpringBoot: 1.5.10.RELEASE

添加 Web 和 thymeleaf 起步依赖
1
2
3
4
5
6
7
8
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
创建 home.html
1
2
3
4
5
6
7
8
9
10
11
12
<!DOCTYPE html>
<html xmlns:th="http://www.w3.org/1999/xhtml">
<head>
  <meta charset="UTF-8"/>
  <title>Spring Security Example</title>
</head>
<body>
  <h1>Welcome!</h1>

  <p>Click <a th:href="@{/hello}">here</a> to see a greeting.</p>
</body>
</html>
创建 hello.html
1
2
3
4
5
6
7
8
9
10
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8"/>
  <title>Hello World！</title>
</head>
<body>
  <h1>Hello World!</h1>
</body>
</html>
配置 MvcConfig 配置类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class MvcConfig extends WebMvcConfigurerAdapter{
	
	@Override
	public void addViewControllers(ViewControllerRegistry registry) {
		super.addViewControllers(registry);
		registry.addViewController("/home").setViewName("home");
		registry.addViewController("/").setViewName("home");
		registry.addViewController("/hello").setViewName("hello");
		registry.addViewController("/login").setViewName("login");
	}
}

Override addViewControllers() 方法，添加四个视图控制器。
两个视图控制器，引用 home 的视图
一个视图控制器，引用 hello 的视图
一个视图控制器，引用 login 的视图（后续添加）

创建应用启动类
1
2
3
4
5
6
7
8
9
10
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BootApplication {
	
	public static void main(String[] args) {
		SpringApplication.run(BootApplication.class, args);
	}
}
添加 security 依赖
1
2
3
4
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>
添加 WebSecurityConfig 配置类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
	
	@Override
	protected void configure(HttpSecurity http) throws Exception {
		super.configure(http);
		http.authorizeRequests()
			.antMatchers("/", "/home").permitAll()
			.anyRequest().authenticated()
			.and()
			.formLogin()
			.loginPage("/login")
			.permitAll()
			.and()
			.logout()
			.permitAll();
	}
	
	@Autowired
	public void configureGlobal(AuthenticationManagerBuilder authenticationManagerBuilder)
		throws Exception {
		authenticationManagerBuilder.inMemoryAuthentication()
									.withUser("user")
									.password("password")
									.roles("USER");
	}
}

WebSecurityConfig 类使用了 @EnableWebSecurity 注解，以启用 Spring Security 的 Web 安全支持，并提供 Spring MVC 集成。继承了 WebSecurityConfigurerAdapter 并覆写了一些方法来设置 Web 安全配置的一些细节。

config(HttpSecurity) 方法定义了哪些 URL 路径应该被保护，哪些不应该被保护。
此处设置 / 和 home 不需要任何身份验证，其他任何 URL 均需要身份验证。

当用户成功登录时，它们将被重定向到先前请求的需要身份验证的页面。有一个由 loginPage() 指定的自定义 /login 页面，每个人都可以查看它。

configureGlobal(AuthenticationManagerBuilder) 方法将用户信息和用户的角色信息设置在内存中。

添加 login.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<head>
  <meta charset="UTF-8"/>
  <title>Spring Security Example</title>
</head>
<body>
  <div th:if="${param.error}">
    Invalid username and password.
  </div>
  <div th:if="${param.logout}">
    You have been logged out.
  </div>
  <form th:action="@{/login}" method="post">
    <div>
      <label>
        User Name : <input type="text" name="username" />
      </label>
    </div>
    <div>
      <label>
        Password : <input type="password" name="password" />
      </label>
    </div>
    <div>
      <input type="submit" value="Sign In" />
    </div>
  </form>
</body>
</html>

Thymeleaf 模板只是提供一个表单来获取用户名和密码，并将它们提交到 “/login”。
根据配置， Spring Security 提供了一个拦截该请求并验证用户的过滤器。如果用户未通过认证，该页面将重定向到 “/login?error” , 并在页面显示响应的错误消息。注销成功后，将送到 “/login?logout” ，并在页面显示相应的登出成功消息。

更新 hello.html
1
2
3
4
5
6
7
8
9
10
11
12
13
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<head>
  <meta charset="UTF-8"/>
  <title>Hello World！</title>
</head>
<body>
  <h1 th:inline="text">Hello [[${#httpServletRequest.remoteUser}]]!</h1>
  <form th:action="@{/logout}" method="post">
    <input type="submit" value="Sign Out" />
  </form>
</body>
</html>

使用 Spring Security 与 HttpServletRequest#getRemoteUser() 集成显示用户名。
“登出” 表单将 POST 请求提交到 “/logout”。成功注销后，会将用户重定向到 ”/login?logout”。

测试

访问：http://localhost:8080
应用将进入 login 页面，根据提示输入账号：user，密码：password。

代码已上传 GitHub https://github.com/lxmuse/lxmuse-spring-boot 下 example-spring-boot/example-security-01

展开全文 >>

《深入理解Java虚拟机》学习系列环境准备篇

本学习系列将基于《深入理解Java虚拟机》第2版
环境使用 CentOS 6.5 64.bit 操作系统。
选择安装 OpenJDK 8。

切换 CentOS 6.5 镜像源

1
2
3
4
5
[root@localhost openjdk]# cd /etc/yum.repos.d/
[root@localhost yum.repos.d]# mv CentOS-Base.repo CentOS-Base.repo.bk
[root@localhost yum.repos.d]# wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo
[root@localhost yum.repos.d]# yum clean all
[root@localhost yum.repos.d]# yum makecache

安装 Bootstrap JDK

参考官方说明，CentOS 6.5 下执行 yum install java-1.8.0-openjdk

1
[root@localhost Desktop]# yum -y install java-1.8.0-openjdk

安装完毕以后执行 java -version :

1
2
3
4
[root@localhost Desktop]# java -version
openjdk version "1.8.0_151"
OpenJDK Runtime Environment (build 1.8.0_151-b12)
OpenJDK 64-Bit Server VM (build 25.151-b12, mixed mode)

下载 OpenJDK 1.8 源码

安装 hg：

1
[root@localhost Desktop]# yum -y install hg

执行下载：

1
[root@localhost Desktop]# hg clone http://hg.openjdk.java.net/jdk8u/jdk8u openjdk8

该方式非常缓慢，经常中断，故直接从网站通过其他方式下载源码：下载链接

1
2
3
[root@localhost Desktop]# ll
total 121192
-rw-r--r--. 1 root root 124099402 Nov 29 15:36 openjdk-8-src-b132-03_mar_2014.zip

安装编译依赖

1
[root@localhost Desktop]# yum -y install alsa-lib-devel cups-devel libX* gcc gcc-c++ freetype-devel libstdc++-static ant make

编译配置

1
2
3
[root@localhost Desktop]# cd openjdk
[root@localhost openjdk]# chmod +x configure
[root@localhost openjdk]# ./configure --enable-debug

编译

1
[root@localhost openjdk]# make CONF=linux-x86_64-normal-server-fastdebug

出现如下信息，表示编译结束：

1
2
3
4
5
6
7
8
9
10
11
12
----- Build times -------
Start 2017-11-29 15:55:35
End   2017-11-29 16:04:09
00:00:25 corba
00:04:38 hotspot
00:00:14 jaxp
00:00:19 jaxws
00:02:25 jdk
00:00:33 langtools
00:08:34 TOTAL
-------------------------
Finished building OpenJDK for target 'default'

验证

1
2
3
4
5
6
7
8
9
[root@localhost openjdk]# build/linux-x86_64-normal-server-fastdebug/jdk/bin/java -version
openjdk version "1.8.0-internal-fastdebug"
OpenJDK Runtime Environment (build 1.8.0-internal-fastdebug-root_2017_11_29_15_46-b00)
OpenJDK 64-Bit Server VM (build 25.0-b70-fastdebug, mixed mode)

[root@localhost openjdk]# java -version
openjdk version "1.8.0_151"
OpenJDK Runtime Environment (build 1.8.0_151-b12)
OpenJDK 64-Bit Server VM (build 25.151-b12, mixed mode)

展开全文 >>

SpringBoot CommandLineRunner 初识

在 SpringBoot 官方 Guides Building an Application with Spring Boot 中看到一段如下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package hello;

import java.util.Arrays;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
        return args -> {

            System.out.println("Let's inspect the beans provided by Spring Boot:");

            String[] beanNames = ctx.getBeanDefinitionNames();
            Arrays.sort(beanNames);
            for (String beanName : beanNames) {
                System.out.println(beanName);
            }

        };
    }

}

其中实现了一个 CommandLineRunner 匿名内部类，那么 CommandLineRunner 接口有哪些作用呢？工作机制又是什么？

SpringBoot Reference 1.5.9.RELEASE 23.8 Using the ApplicationRunner or CommmandLineRunner 中有这么一段话：

1
If you need to run some specific code once the SpringApplication has started, you can implement the ApplicationRunner or CommandLineRunner interfaces. Both interfaces work in the same way and offer a single run method which will be called just before SpringApplication.run(…​) completes.

创建一个普通的 SpringBoot Application，并编写一个CommandLineRunner 实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.example.springboot.commandlinerunner;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class HelloCommandLineRunner implements CommandLineRunner {

	@Override
	public void run(String... strings) throws Exception {
		System.out.println("Hello CommandLineRunner");
	}

}

运行该 SpringBoot Application，控制台将出现如下输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.9.RELEASE)

2017-11-29 19:53:28.157  INFO 10544 --- [           main] ingBootCommandLineRunnerHelloApplication : Starting SpringBootCommandLineRunnerHelloApplication on DESKTOP-49M29KH with PID 10544 (D:\lxmuse-spring-boot\spring-boot-command-line-runner\spring-boot-command-line-runner-hello\target\classes started by Richard in D:\lxmuse-spring-boot\spring-boot-command-line-runner\spring-boot-command-line-runner-hello)
2017-11-29 19:53:28.159  INFO 10544 --- [           main] ingBootCommandLineRunnerHelloApplication : No active profile set, falling back to default profiles: default
2017-11-29 19:53:28.220  INFO 10544 --- [           main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@6dde5c8c: startup date [Wed Nov 29 19:53:28 CST 2017]; root of context hierarchy
2017-11-29 19:53:28.737  INFO 10544 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
Hello CommandLineRunner
2017-11-29 19:53:28.746  INFO 10544 --- [           main] ingBootCommandLineRunnerHelloApplication : Started SpringBootCommandLineRunnerHelloApplication in 0.833 seconds (JVM running for 1.802)
2017-11-29 19:53:28.747  INFO 10544 --- [       Thread-4] s.c.a.AnnotationConfigApplicationContext : Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@6dde5c8c: startup date [Wed Nov 29 19:53:28 CST 2017]; root of context hierarchy
2017-11-29 19:53:28.749  INFO 10544 --- [       Thread-4] o.s.j.e.a.AnnotationMBeanExporter        : Unregistering JMX-exposed beans on shutdown

可以发现，在完全启动前已经执行了 HelloCommandLineRunner 中的 run 方法。

Reference 中提到 ApplicationRunner 和 CommmandLineRunner 具有相同的作用。
同理编写一个 ApplicationRunner 实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.example.springboot.commandlinerunner;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class HelloApplicationRunner implements ApplicationRunner {

	@Override
	public void run(ApplicationArguments applicationArguments) throws Exception {
		System.out.println("Hello ApplicationRunner");
	}
}

重新运行 SpringBoot Application，控制台将出现如下输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.9.RELEASE)

2017-11-29 20:02:17.920  INFO 6548 --- [           main] ingBootCommandLineRunnerHelloApplication : Starting SpringBootCommandLineRunnerHelloApplication on DESKTOP-49M29KH with PID 6548 (D:\lxmuse-spring-boot\spring-boot-command-line-runner\spring-boot-command-line-runner-hello\target\classes started by Richard in D:\lxmuse-spring-boot\spring-boot-command-line-runner\spring-boot-command-line-runner-hello)
2017-11-29 20:02:17.922  INFO 6548 --- [           main] ingBootCommandLineRunnerHelloApplication : No active profile set, falling back to default profiles: default
2017-11-29 20:02:17.969  INFO 6548 --- [           main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@5123a213: startup date [Wed Nov 29 20:02:17 CST 2017]; root of context hierarchy
2017-11-29 20:02:18.534  INFO 6548 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
Hello ApplicationRunner
Hello CommandLineRunner
2017-11-29 20:02:18.546  INFO 6548 --- [           main] ingBootCommandLineRunnerHelloApplication : Started SpringBootCommandLineRunnerHelloApplication in 0.829 seconds (JVM running for 1.294)
2017-11-29 20:02:18.547  INFO 6548 --- [       Thread-4] s.c.a.AnnotationConfigApplicationContext : Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@5123a213: startup date [Wed Nov 29 20:02:17 CST 2017]; root of context hierarchy
2017-11-29 20:02:18.548  INFO 6548 --- [       Thread-4] o.s.j.e.a.AnnotationMBeanExporter        : Unregistering JMX-exposed beans on shutdown

可以发现，在完全启动前已经执行了 HelloApplicationRunner 和 HelloCommandLineRunner 中的 run 方法。
并且 HelloApplicationRunner 中的 run 方法优先执行。

那么 @Order 对其有没有影响呢？
在 HelloApplicationRunner 上添加 @Order 注解，并且指定值为 2；
在 HelloCommandLineRunner 上添加 @Order 注解，并且指定值为 1；

重新运行 SpringBoot Application，控制台将出现如下输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.9.RELEASE)

2017-11-29 20:09:21.078  INFO 772 --- [           main] ingBootCommandLineRunnerHelloApplication : Starting SpringBootCommandLineRunnerHelloApplication on DESKTOP-49M29KH with PID 772 (D:\lxmuse-spring-boot\spring-boot-command-line-runner\spring-boot-command-line-runner-hello\target\classes started by Richard in D:\lxmuse-spring-boot\spring-boot-command-line-runner\spring-boot-command-line-runner-hello)
2017-11-29 20:09:21.080  INFO 772 --- [           main] ingBootCommandLineRunnerHelloApplication : No active profile set, falling back to default profiles: default
2017-11-29 20:09:21.139  INFO 772 --- [           main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@5123a213: startup date [Wed Nov 29 20:09:21 CST 2017]; root of context hierarchy
2017-11-29 20:09:21.604  INFO 772 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
Hello CommandLineRunner
Hello ApplicationRunner
2017-11-29 20:09:21.622  INFO 772 --- [           main] ingBootCommandLineRunnerHelloApplication : Started SpringBootCommandLineRunnerHelloApplication in 0.755 seconds (JVM running for 1.256)
2017-11-29 20:09:21.623  INFO 772 --- [       Thread-4] s.c.a.AnnotationConfigApplicationContext : Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@5123a213: startup date [Wed Nov 29 20:09:21 CST 2017]; root of context hierarchy
2017-11-29 20:09:21.625  INFO 772 --- [       Thread-4] o.s.j.e.a.AnnotationMBeanExporter        : Unregistering JMX-exposed beans on shutdown

HelloCommandLineRunner 将根据指定的顺序优先执行。

那么相同类型的实现类执行顺序又是如何呢？
其真正的执行原理又是什么呢？
留待再探时再解密吧！（需要深入源码）

具体代码已上传GitHub-lxmuse

展开全文 >>

SpringBoot 整合 MyBatis 系列三

SpringBoot 整合 MyBatis 三探

本次将结合前两篇 SpringBoot 整合 MyBatis 初探、SpringBoot 整合 MyBatis 再探 进行整合。

数据库准备

参考 SpringBoot 整合 MyBatis 初探 中的数据库准备

SpringBoot 工程准备

参考 SpringBoot 整合 MyBatis 初探 中的 SpringBoot 工程准备

配置 SpringBoot 配置文件

采用 yml 格式配置文件。yml 格式更有层次感，而且默认编码格式 UTF-8，支持中文参数。
application.yml 内容如下：

1
2
3
4
5
6
7
8
9
spring:
  datasource:
    url: jdbc:mysql://192.168.0.110:3306/spring-boot?useSSL=false&useUnicode=true&characterEncoding=utf8
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

mybatis:
  mapper-locations: classpath:mapper/*.xml

配置数据源连接信息，以及 MyBatis Mapper.xml 映射文件位置

编写 persistence 层

Entity 可以参考 SpringBoot 整合 MyBatis 初探 中的 UserEntity 类

Mapper 接口存在一些小小的不同：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.example.persistence.mapper;

import com.example.persistence.entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserMapper {

	UserEntity getByUserId(String userId);

}

类上使用 @Mapper 注解，MyBatis 可以自动识别被该注解标准的类，运行时将自动生成代理类

编写 Mapper.xml 文件

Mapper.xml 根据 SpringBoot 配置文件中的设置，约定于 resources/mapper 目录下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?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.example.persistence.mapper.UserMapper">
  <resultMap id="BaseResultMap" type="com.example.persistence.entity.UserEntity">
    <result column="id" property="id" />
    <result column="user_id" property="userId" />
    <result column="user_name" property="userName" />
  </resultMap>

  <sql id="Base_Column_List">
    id, user_id, user_name
  </sql>

  <select id="getByUserId" resultMap="BaseResultMap" parameterType="java.lang.String">
    SELECT
    <include refid="Base_Column_List" />
    FROM user_info
    WHERE user_id = #{userId, jdbcType=VARCHAR}
  </select>

</mapper>

编写 Service 层

参考 SpringBoot 整合 MyBatis 初探 中的 编写 Service 层

编写 Controller 层

参考 SpringBoot 整合 MyBatis 初探 中的 编写 Controller 层

编写 SpringBoot Application 启动类

参考 SpringBoot 整合 MyBatis 再探 Application 类

运行 UserApplication , 通过浏览器或者 PostMan 等模拟请求工具模拟 GET 请求即可测试接口是否正确返回数据。

Mapper 接口通过 @Mapper 注解自动识别，将 SQL 写在 Mapper.xml 文件内，是比较推荐的方法。这也是三探的意义所在。

具体代码已上传GitHub-lxmuse

展开全文 >>

SpringBoot 整合 MyBatis 系列二

SpringBoot 整合 MyBatis 再探

在上一篇 SpringBoot 整合 MyBatis 初探 中使用@MapperScan注解结合 Mapper.xml 文件 实现 SpringBoot和MyBatis 整合，本次将使用注解方式实现 SpringBoot和MyBaits 整合。

数据库准备

参考 SpringBoot 整合 MyBatis 初探 中的数据库准备

SpringBoot 工程准备

参考 SpringBoot 整合 MyBatis 初探 中的 SpringBoot 工程准备

配置 SpringBoot 配置文件

采用 yml 格式配置文件。yml 格式更有层次感，而且默认编码格式 UTF-8，支持中文参数。
application.yml 内容如下：

1
2
3
4
5
6
spring:
  datasource:
    url: jdbc:mysql://192.168.0.110:3306/spring-boot?useSSL=false&useUnicode=true&characterEncoding=utf8
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

只需要配置数据源连接信息，不需要配置 MyBatis Mapper.xml 映射文件位置

编写 persistence 层

Entity 可以参考 SpringBoot 整合 MyBatis 初探 中的 UserEntity 类

Mapper 接口存在一些小小的不同：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.example.persistence.mapper;

import com.example.persistence.entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserMapper {

	@Select("SELECT id, user_id, user_name FROM user_info WHERE user_id = #{userId, jdbcType=VARCHAR}")
	@Results({
		@Result(property = "id", column = "id"),
		@Result(property = "userId", column = "user_id"),
		@Result(property = "userName", column = "user_name")
	})
	UserEntity getByUserId(String userId);

}

首先，类上使用 @Mapper 注解，MyBatis 可以自动识别被该注解标准的类，运行时将自动生成代理类
其次，方法上使用 @Select 注解，指定其SQL；使用 @Results 注解，定义其返回映射，等同于ResultMap

因为使用了注解，Mapper.xml 文件可以省略。

编写 Service 层

参考 SpringBoot 整合 MyBatis 初探 中的 编写 Service 层

编写 Controller 层

参考 SpringBoot 整合 MyBatis 初探 中的 编写 Controller 层

编写 SpringBoot Application 启动类

遵循 SpringBoot Application 默认约定，在 com.example 包根路径定义 Appplication 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class UserApplication {

	public static void main(String[] args) {
		SpringApplication.run(UserApplication.class,args);
	}

}

仅仅只需要 @SpringBootApplication 注解即可。

运行 UserApplication , 通过浏览器或者 PostMan 等模拟请求工具模拟 GET 请求即可测试接口是否正确返回数据。

本次整合，只是入门级的简单应用，更负杂的场景需要根据相关官方文档进行更多的实践。

具体代码已上传GitHub-lxmuse

展开全文 >>

SpringBoot 整合 MyBatis 系列一

SpringBoot 整合MyBatis 初探

数据库准备

创建 user_info 表：

1
2
3
4
5
6
CREATE TABLE user_info (
  id bigint(20) NOT NULL AUTO_INCREMENT COMMENT '自增主键',
  user_id varchar(32) DEFAULT NULL COMMENT '用户标识',
  user_name varchar(255) DEFAULT NULL COMMENT '用户姓名',
  PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

初始化数据：

1
2
INSERT INTO user_info VALUES ('1', '33C21A1821BA43D5AB206AB711750599', '张三');
INSERT INTO user_info VALUES ('2', '5FD890AB3D5F448B9B2BAEF9772EF5AF', '李四');

SpringBoot 工程准备

采用 dependencyManagement 标签方式引入 SpringBoot 依赖，该方式较 parent 标签方式更加灵活。

1
2
3
4
5
6
7
8
9
10
11
12
<dependencyManagement>
  <dependencies>
    <dependency>
      <!-- Import dependency management from Spring Boot -->
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>1.5.6.RELEASE</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

添加如下所需依赖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<properties>
  <mybatis-spring-boot>1.3.1</mybatis-spring-boot>
  <mysql-connector>5.1.44</mysql-connector>
</properties>

<dependencies>
  <!-- Spring Boot Web 依赖 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <!-- Spring Boot Test 依赖 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
  <!-- Spring Boot Mybatis 依赖 -->
  <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>${mybatis-spring-boot}</version>
  </dependency>
  <!-- MySQL 连接驱动依赖 -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql-connector}</version>
  </dependency>
</dependencies>

配置 SpringBoot 配置文件

采用 yml 格式配置文件。yml 格式更有层次感，而且默认编码格式 UTF-8，支持中文参数。
application.yml 内容如下：

1
2
3
4
5
6
7
8
9
spring:
  datasource:
    url: jdbc:mysql://192.168.0.110:3306/spring-boot?useSSL=false&useUnicode=true&characterEncoding=utf8
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

mybatis:
  mapper-locations: classpath:mapper/*.xml

配置数据源连接信息，以及 MyBatis Mapper.xml 映射文件位置

编写 persistence 层

persistence 层包含 Entity 类 及 Mapper 接口。
com.example.persistence.entity 包内定义 UserEntity 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com.example.persistence.entity;

public class UserEntity {

	private Long id;
	private String userId;
	private String userName;

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getUserId() {
		return userId;
	}

	public void setUserId(String userId) {
		this.userId = userId;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	@Override
	public String toString() {
		return "UserEnitity{" +
			"id=" + id +
			", userId='" + userId + '\'' +
			", userName='" + userName + '\'' +
			'}';
	}
}

com.example.persistence.mapper 包内定义 UserMapper 接口：

1
2
3
4
5
6
7
8
9
package com.example.persistence.mapper;

import com.example.persistence.entity.UserEntity;

public interface UserMapper {

	UserEntity getByUserId(String userId);

}

编写 Mapper.xml 文件

Mapper.xml 根据 SpringBoot 配置文件中的设置，约定于 resources/mapper 目录下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?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.example.persistence.mapper.UserMapper">
  <resultMap id="BaseResultMap" type="com.example.persistence.entity.UserEntity">
    <result column="id" property="id" />
    <result column="user_id" property="userId" />
    <result column="user_name" property="userName" />
  </resultMap>

  <sql id="Base_Column_List">
    id, user_id, user_name
  </sql>

  <select id="getByUserId" resultMap="BaseResultMap" parameterType="java.lang.String">
    SELECT
    <include refid="Base_Column_List" />
    FROM user_info
    WHERE user_id = #{userId, jdbcType=VARCHAR}
  </select>

</mapper>

编写 Service 层

service 层包含 Service 接口和 Service 实现类。
com.example.service 包内定义 UserService 接口：

1
2
3
4
5
6
7
8
package com.example.service;

import com.example.persistence.entity.UserEntity;

public interface UserService {

	UserEntity getByUserId(String userId);
}

com.example.service.impl 包内定义 UserServiceImpl 实现类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.example.service.impl;

import com.example.persistence.entity.UserEntity;
import com.example.persistence.mapper.UserMapper;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserMapper userMapper;

	public UserEntity getByUserId(String userId) {
		return userMapper.getByUserId(userId);
	}

}

编写 Controller 层

com.example.controller 包内定义 UserController 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.example.controller;

import com.example.persistence.entity.UserEntity;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

	@Autowired
	private UserService userService;

	@RequestMapping(value = "/user/{userId}")
	public UserEntity getByUserId(@PathVariable String userId) {
		return userService.getByUserId(userId);
	}
}

编写 SpringBoot Application 启动类

遵循 SpringBoot Application 默认约定，在 com.example 包根路径定义 Appplication 类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.example;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan(basePackages = {"com.example.persistence.mapper"})
@SpringBootApplication
public class UserApplication {

	public static void main(String[] args) {
		SpringApplication.run(UserApplication.class,args);
	}

}

@SpringBootApplication 注解是 SpringBoot 基础注解，在此就不详细解释了。
@MapperScan 注解是 Mybatis 和 Spring 整合时的一个注解。 MyBatis 和 Spring 整合时，需要知道 Mapper 接口所在位置，以便运行时生成 Mapper 的代理类。其中 basePackagees 属性用于指定 Mapper 接口所在包路径。支持多个包路径配置，如 basePackages = {“xx”,”xxx”}。其他属性后续遇到再解释。

因为采用默认的自动配置策略，故 @MapperScan 注解标注在 SpringBoot Application 类上，若使用配置类方式自定义配置，也可将该注解标注于配置类上。

运行 UserApplication , 通过浏览器或者 PostMan 等模拟请求工具模拟 GET 请求即可测试接口是否正确返回数据。

本次整合，只是入门级的简单应用，更负杂的场景需要根据相关官方文档进行更多的实践。

具体代码已上传GitHub-lxmuse

展开全文 >>

需求分析与系统设计

需求分析

  1. 当用户进入 “客户管理” 模块时，可通过列表方式来查看所有客户
  2. 可通过 “客户名称” 关键字进行模糊查询
  3. 单击客户列表中的 “客户名称” 链接，可查看客户基本信息
  4. 单击 “新增” 按钮，进入 “新增客户” 界面，可新增客户基本信息
  5. 单击客户列表中的 “编辑” 按钮，进入 “编辑客户” 界面，可更新客户基本信息
  6. 单击客户列表中的 “删除” 按钮，可删除当前所选择的客户，需提示是否删除
  7. 客户信息包括：客户名称、联系人、电话号码、邮箱地址、备注

用例设计

  • 查询客户
  • 显示客户列表
  • 显示客户基本信息
  • 新建客户
  • 编辑客户基本信息
  • 删除客户

用例图

表结构设计

客户：

字段名 数据类型 是否非空 字段描述
id BIGINT 是 自增主键
name VARCHAR(255) 是 客户名称
contact VARCHAR(255) 是 联系人
telephone VARCHAR(255) 否 电话号码
email VARCHAR(255) 否 邮箱地址
remark TEXT 否 备注

界面原型

请求URL

序号 URL 描述
1 GET:/customer 进入 “客户列表” 界面
2 POST:/customer-search 查询客户
3 GET:/customer-show?id={id} 进入 “查看客户” 界面
4 GET:/customer-create 进入 “创建客户” 界面
5 POST:/customer-create 创建客户
6 GET:/customer-edit?id={id} 进入 “编辑客户” 界面
7 PUT:/customer-edit?id={id} 编辑客户
8 DELETE:/customer-delete?id={id} 删除客户

创建数据库表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
CREATE TABLE customer (
	id BIGINT (20) NOT NULL AUTO_INCREMENT,
	NAME VARCHAR (255) DEFAULT NULL,
	contact VARCHAR (255) DEFAULT NULL,
	telephone VARCHAR (255) DEFAULT NULL,
	email VARCHAR (255) DEFAULT NULL,
	remark text,
	PRIMARY KEY (id)
) ENGINE = INNODB DEFAULT CHARSET = utf8;

INSERT INTO customer
VALUES
	(
		'1',
		'customer1',
		'Jack',
		'13512345678',
		'jack@gmail.com',
		NULL
	);

INSERT INTO customer
VALUES
	(
		'2',
		'customer2',
		'Rose',
		'13623456789',
		'rose@gmail.com',
		NULL
	);

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家