SpringBoot 项目脚手架
写在前面
之前也一直很少有写SpringBoot项目相关的文章，今天 准备整理一个我自己初始化SpringBoot项目时的一个脚手架,便于自己后面查阅。因为SpringBoot的约定大于配置，在整合各个组件的时候，我们仅仅写很少的代码就能 整合 跑起来。
本文，也仅仅是一个简单的整合，更多个性化配置，更多调优，这个也是自己在工作中慢慢摸索的。如果你有什么更多好的建议或者意见，也可以留言交流。谢谢~
我们开始吧
新建SpringBoot
标题1：AOP 切面统一打印请求日志
意图：可以看到，每个对于每个请求，开始与结束一目了然，并且打印了以下参数：
URL: 请求接口地址；
HTTP Method: 请求的方法，是 POST, GET, 还是 DELETE 等；
Class Method: 对应 Controller 的全路径以及调用的哪个方法;
IP: 请求 IP 地址；
Request Args: 请求入参，以 JSON 格式输出；
Response Args: 响应出参，以 JSON 格式输出；
Time-Consuming: 请求耗时；
步骤一：添加依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<!-- 用于日志切面中，以 json 格式打印出入参 -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>
<!-- lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
步骤二：新建一个包aspect
自定义一个注解：
import java.lang.annotation.*;
/**
* Description: TODO
*
* @Author: 留歌36
* @Date: 2019-11-27 15:43
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface WebLog {
/** 日志描述信息 */
String description() default "";
}
新建注解类：
import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
/**
* Description: 查看 https://www.cnblogs.com/quanxiaoha/p/10414681.html
*
* @Author: 留歌36
* @Date: 2019-11-08 11:00
*/
@Aspect
@Component
@Slf4j
public class WebLogAspect {
/** 换行符 */
private static final String LINE_SEPARATOR = System.lineSeparator();
/** 以自定义 @WebLog 注解为切点 */
@Pointcut("@annotation(com.csylh.boot2all.aspect.WebLog)")
public void webLog() {}
/**
* 在切点之前织入
* @param joinPoint
* @throws Throwable
*/
@Before("webLog()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
// 开始打印请求日志
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
// 获取 @WebLog 注解的描述信息
String methodDescription = getAspectLogDescription(joinPoint);
// 打印请求相关参数
log.info("========================================== Start ==========================================");
// 打印请求 url
log.info("URL : {}", request.getRequestURL().toString());
// 打印描述信息
log.info("Description : {}", methodDescription);
// 打印 Http method
log.info("HTTP Method : {}", request.getMethod());
// 打印调用 controller 的全路径以及执行方法
log.info("Class Method : {}.{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());
// 打印请求的 IP
log.info("IP : {}", request.getRemoteAddr());
// 打印请求入参
log.info("Request Args : {}", new Gson().toJson(joinPoint.getArgs()));
}
/**
* 在切点之后织入
* @throws Throwable
*/
@After("webLog()")
public void doAfter() throws Throwable {
// 接口结束后换行，方便分割查看
log.info("=========================================== End ===========================================" + LINE_SEPARATOR);
}
/**
* 环绕
* @param proceedingJoinPoint
* @return
* @throws Throwable
*/
@Around("webLog()")
public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
Object result = proceedingJoinPoint.proceed();
// 打印出参
log.info("Response Args : {}", new Gson().toJson(result));
// 执行耗时
log.info("Time-Consuming : {} ms", System.currentTimeMillis() - startTime);
return result;
}
/**
* 获取切面注解的描述
*
* @param joinPoint 切点
* @return 描述信息
* @throws Exception
*/
public String getAspectLogDescription(JoinPoint joinPoint)
throws Exception {
String targetName = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName();
Object[] arguments = joinPoint.getArgs();
Class targetClass = Class.forName(targetName);
Method[] methods = targetClass.getMethods();
StringBuilder description = new StringBuilder("");
for (Method method : methods) {
if (method.getName().equals(methodName)) {
Class[] clazzs = method.getParameterTypes();
if (clazzs.length == arguments.length) {
description.append(method.getAnnotation(WebLog.class).description());
break;
}
}
}
return description.toString();
}
}
就这样就OK。测试：
标题2：Swagger 整合
意图：生成文档形式的API并提供给不同的团队使用
便于自己单测
无需过多冗余的word文档，这一点很重要，因为我在工作中就遇到这么一个情况，由于开发使用的文档和最新文档版本导致不一致，导致后期很烦人
步骤一：添加依赖
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.4.0</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.4.0</version>
</dependency>
步骤2：新建swagger2配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.ParameterBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.schema.ModelRef;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.service.Parameter;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
import java.util.ArrayList;
import java.util.List;
/**
* Description:
*
* @author: 留歌36
* Date:2018/9/14 16:29
*/
@Configuration
@EnableSwagger2
public class Swagger2 {
/**
* @Description:swagger2的配置文件，这里可以配置swagger2的一些基本的内容，比如扫描的包等等
*/
@Bean
public Docket createRestApi() {
// 为swagger添加header参数可供输入
// ParameterBuilder userTokenHeader = new ParameterBuilder();
// ParameterBuilder userIdHeader = new ParameterBuilder();
// List<Parameter> pars = new ArrayList<Parameter>();
// userTokenHeader.name("headerUserToken").description("userToken")
// .modelRef(new ModelRef("string")).parameterType("header")
// .required(false).build();
// userIdHeader.name("headerUserId").description("userId")
// .modelRef(new ModelRef("string")).parameterType("header")
// .required(false).build();
// pars.add(userTokenHeader.build());
// pars.add(userIdHeader.build());
return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
// 注意修改这里 .apis(RequestHandlerSelectors.basePackage("com.zd.tongnan.controller"))
.paths(PathSelectors.any()).build()
.globalOperationParameters(setHeaderToken());
// .globalOperationParameters(pars);
}
private List<Parameter> setHeaderToken() {
ParameterBuilder tokenPar = new ParameterBuilder();
List<Parameter> pars = new ArrayList<>();
tokenPar.name("token").description("token").modelRef(new ModelRef("string")).parameterType("header").required(false).build();
pars.add(tokenPar.build());
return pars;
}
/**
* @Description: 构建 api文档的信息
*/
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
// 设置页面标题
.title("xxx系统-接口数据文档")
// 描述
.description("xxx接口数据文档")
// 设置联系人
.contact(new Contact("留歌36","https://blog.csdn.net/liuge36",""))
// .contact(new Contact("留歌36", "http://csylh.cn", "csylh36@163.com"))
// 定义版本号
.version("V-1.0.0").build();
}
}
步骤三：使用注解 ，主要是配置 在 controller类名，controller方法 和 实体类这三个地方
demo:
controller 类名上
@Api(value = “用户注册登录接口”,tags = {“登录注册注销的controller”})
public class UserController{}
controller类 方法名上
@ApiOperation：用在请求的方法上，说明方法的用途、作用
- value=“说明方法的用途、作用”
- notes=“方法的备注说明”
案例：
@ApiOperation(value = “用户注册接口”, notes=“这是用户注册的接口，随便写都可以”)
public ServerResponse register(@RequestBody Users user){
return iUserService.register(user);
}
controller 类方法参数上
重点 两大类：
1.@RequestParam ⇒ @ApiImplicitParams
使用@ApiImplicitParams来定义参数
@ApiImplicitParams({
@ApiImplicitParam(name="name",value="内存名",dataType="string", paramType = "query"),
})
2.@RequestBody ⇒ @ApiModelProperty(value = "用户名",name = "username",example = "admin",required = true) :注：这里是在对应的实体类上的各个属性上添加注解
区别：一个是在实体类上添加注解@ApiModelProperty
一个是在方法 参数上面添加注解@ApiImplicitParams
更多使用，参考 这里
标题3：Mybatis 整合
意图：这个是常用的持久层框架，虽然spring-data-jpa也是很优秀的。但是我自己在工作中这个用的比较多一点。
SpringBoot 整合 Mybatis 有两种常用的方式，一种就是我们常见的 xml 的方式 ，还有一种是全注解的方式。
如何选择：在 SQL 语句不太长的情况下，我觉得全注解的方式一定是比较清晰简洁的。但是，复杂的 SQL 确实不太适合和代码写在一起，那么就使用xml文件的形式。其实这两个方法也没差。
步骤1：添加依赖
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.1</version>
</dependency>
步骤2：配置 application.properties
server.port=9099
# 暂时使用SpringBoot2 自带的 HikariCP 连接池，后面结合Druid
spring.datasource.url=jdbc:mysql://192.168.1.200:3306/test2?useUnicode=true&characterEncoding=UTF-8&useSSL=false
spring.datasource.username=db
spring.datasource.password=xxx
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#Mybatis 配置
mybatis.config-location=classpath:mybatis-config.xml
mybatis.mapper-locations=classpath*:/mappers/**.xml
mybatis.type-aliases-package=com.liuge36.emr.entity
步骤3：resources 下新建mybatis-config.xml ,并建立自己的entity包
<?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>
<!-- 配置全局属性 -->
<settings>
<!-- 使用jdbc的getGeneratedKeys获取数据库自增主键值 -->
<setting name="useGeneratedKeys" value="true" />
<!-- 使用列标签替换列别名 默认:true -->
<setting name="useColumnLabel" value="true" />
<!-- 开启驼峰命名转换:Table{create_time} -> Entity{createTime} -->
<setting name="mapUnderscoreToCamelCase" value="true" />
</settings>
</configuration>
步骤4：测试
新建dao包，新建MemoryDao接口
import cn.com.zdmedical.emr.entity.Memory;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* Description: TODO
*
* @Author: 留歌36
* @Date: 2019-11-28 09:10
*/
@Mapper
public interface MemoryDao {
/** 根据名字查找内存信息 */
Memory findMemoryByName(@Param("name") String name);
}
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.liuge36.emr.dao.MemoryDao">
<select id="findMemoryByName" parameterType="String" resultType="com.liuge36.emr.entity.Memory">
SELECT * FROM memory WHERE name = #{name}
</select>
</mapper>
其余的就是基本的常规业务操作了。
注解的方式：
@Mapper
public interface UserDao {
/**
* 通过名字查询用户信息
*/
@Select("SELECT * FROM user WHERE name = #{name}")
User findUserByName(@Param("name") String name);
/**
* 查询所有用户信息
*/
@Select("SELECT * FROM user")
List<User> findAllUser();
/**
* 插入用户信息
*/
@Insert("INSERT INTO user(name, age,money) VALUES(#{name}, #{age}, #{money})")
void insertUser(@Param("name") String name, @Param("age") Integer age, @Param("money") Double money);
/**
* 根据 id 更新用户信息
*/
@Update("UPDATE user SET name = #{name},age = #{age},money= #{money} WHERE id = #{id}")
void updateUser(@Param("name") String name, @Param("age") Integer age, @Param("money") Double money,
@Param("id") int id);
/**
* 根据 id 删除用户信息
*/
@Delete("DELETE from user WHERE id = #{id}")
void deleteUser(@Param("id") int id);
}
所以，其实SpringBoot整合这些框架的 基本 使用还是很简单的。
标题4：Druid 数据库连接池 整合
https://github.com/alibaba/druid
阿里巴巴数据库事业部出品，为监控而生的数据库连接池
Druid是Java语言中最好的数据库连接池。Druid能够提供强大的监控和扩展功能。
步骤1：添加依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.10</version>
</dependency>
步骤2：配置 application.properties
#spring.datasource.url=jdbc:mysql://192.168.1.200:3306/test2?useUnicode=true&characterEncoding=UTF-8&useSSL=false
#spring.datasource.username=root
#spring.datasource.password=xx
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# 这4个参数key里不带druid也可以，即可以还用上面的这个4个参数
spring.datasource.druid.url=jdbc:mysql://192.168.1.200:3306/test2?useUnicode=true&characterEncoding=UTF-8&useSSL=false
spring.datasource.druid.username=root
spring.datasource.druid.password=xx
spring.datasource.druid.driver-class-name=com.mysql.jdbc.Driver
# 初始化时建立物理连接的个数
spring.datasource.druid.initial-size=5
# 最大连接池数量
spring.datasource.druid.max-active=30
# 最小连接池数量
spring.datasource.druid.min-idle=5
# 获取连接时最大等待时间，单位毫秒
spring.datasource.druid.max-wait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.druid.time-between-eviction-runs-millis=60000
# 连接保持空闲而不被驱逐的最小时间
spring.datasource.druid.min-evictable-idle-time-millis=300000
# 用来检测连接是否有效的sql，要求是一个查询语句
spring.datasource.druid.validation-query=SELECT 1 FROM DUAL
# 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
spring.datasource.druid.test-while-idle=true
# 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
spring.datasource.druid.test-on-borrow=false
# 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
spring.datasource.druid.test-on-return=false
# 是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
spring.datasource.druid.pool-prepared-statements=true
# 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。
spring.datasource.druid.max-pool-prepared-statement-per-connection-size=50
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计
spring.datasource.druid.filters=stat,wall
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
spring.datasource.druid.connection-properties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
# 合并多个DruidDataSource的监控数据
spring.datasource.druid.use-global-data-source-stat=true
步骤3：访问 http://127.0.0.1:9099/druid/index.html
打开mysql客户端navicat的sql窗口，执行show full processlist，显示如下内容：
可以看到，启动项目后，直接创建5个数据连接，这是由application.properties配置文件中spring.datasource.druid.initial-size=5控制的。
步骤4：druid监控
在步骤3我们可以看到，浏览器输入http://127.0.0.1:9099/druid/index.html直接就能看到druid控制台界面，在这里面可以看到很多项目信息，如果任凭用户随意访问，非常危险。我们可以通过配置，设置只有通过登录认证才可以访问。
在application.properties配置文件中增加：
# druid连接池监控
spring.datasource.druid.stat-view-servlet.login-username=admin
spring.datasource.druid.stat-view-servlet.login-password=admin
# 排除一些静态资源，以提高效率
spring.datasource.druid.web-stat-filter.exclusions=*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*
再次访问：http://127.0.0.1:9099/druid/login.html
输入 admin /admin 进去
标题5：通用工具类+通用返回
4个常用JSON类库分别为：Gson，FastJson，Jackson，Json-lib
步骤1：添加依赖
<dependency>
<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-mapper-asl</artifactId>
<version>1.9.13</version>
</dependency>
步骤2：修改配置文件
# 属性为 空（””） 或者为 NULL 都不序列化
spring.jackson.default-property-inclusion=non_empty
步骤3：新建 common 包
在包下新建：ResponseCode
/**
* Description:
*
* @author: 留歌36
* Date:2018/11/4 16:04
*/
public enum ResponseCode {
SUCCESS(200,"成功"),
ERROR(1,"错误"),
NEED_REGISTER(10,"需要注册,请授权登录!"),
NEED_LOGIN(12,"需要登录,请登录!"),
TOMANYLOGIN(11,"账号被挤出."),
ILLEGAL_ARGUMENT(2,"ILLEGAL_ARGUMENT");
private final int code;
private final String desc;
ResponseCode(int code, String desc){
this.code=code;
this.desc=desc;
}
public int getCode(){
return code;
}
public String getDesc(){
return desc;
}
}
新建通用返回对象：
import org.codehaus.jackson.annotate.JsonIgnore;
import org.codehaus.jackson.map.annotate.JsonSerialize;
import java.io.Serializable;
/**
* Description:
*
* @author: 留歌36
* Date:2018/11/4 16:03
*/
@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL)
//保证序列化json的时候,如果是null的对象,key也会消失
public class ServerResponse<T> implements Serializable{
private int status;
private String msg;
private T data;//可以指定泛型里面的内容，也可以不指定，而且里面的类型可以是多种，map,list,string
//编写外部访问的Public方法,之前需要写一个枚举类
//这样外部的显示的就是这几个值啦
public int getStatus(){
return status;
}
public String getMsg(){
return msg;
}
public T getData(){
return data;
}
//判断是否登陆成功
@JsonIgnore
public boolean isSuccess(){
return this.status == ResponseCode.SUCCESS.getCode();
}
//编写 私有 的构造方法，外部是不能new的
// 开放供外部使用的Public方法
private ServerResponse(int status){
this.status=status;
}
private ServerResponse(int status, T data){
this.status=status;
this.data=data;
}
private ServerResponse(int status, String msg){
this.status=status;
this.msg=msg;
}
private ServerResponse(int status, String msg, T data){
this.status=status;
this.msg=msg;
this.data=data;
}
//编写成功静态的方法供外部的调用
public static <T> ServerResponse<T> createBySuccess(){
return new ServerResponse<T>(ResponseCode.SUCCESS.getCode());
}
public static <T> ServerResponse<T> createBySuccess(T data){
return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(),data);
}
public static <T> ServerResponse<T> createBySuccess(String msg,T data){
return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(),msg,data);
}
public static <T> ServerResponse<T> createBySuccessMessage(String msg){
return new ServerResponse<T>(ResponseCode.SUCCESS.getCode(),msg);
}
//编写失败的方法
public static <T> ServerResponse<T> createByError(){
return new ServerResponse<T>(ResponseCode.ERROR.getCode(),ResponseCode.ERROR.getDesc());
}
public static <T> ServerResponse<T> createByErrorMessage(String errorMessage) {
return new ServerResponse<T>(ResponseCode.ERROR.getCode(),errorMessage);
}
public static <T> ServerResponse<T> createByErrorCodeMessage(int errorcode,String erroeMessage){
return new ServerResponse<T>(errorcode,erroeMessage);
}
public static <T> ServerResponse<T> createByErrorNeeDLogin(String erroeMessage){
return new ServerResponse<T>(ResponseCode.NEED_REGISTER.getCode(),erroeMessage);
}
}
允许全局跨域：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
/**
* Description: 配置全局跨域
*
* @Author: 留歌36
* @Date: 2019-11-28 11:45
*/
@Configuration
public class GlobalCorsConfig {
private CorsConfiguration buildConfig() {
CorsConfiguration corsConfiguration = new CorsConfiguration();
corsConfiguration.addAllowedOrigin("*");
corsConfiguration.addAllowedHeader("*");
corsConfiguration.addAllowedMethod("*");
corsConfiguration.setAllowCredentials(true);
return corsConfiguration;
}
@Bean
public CorsFilter corsFilter() {
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", buildConfig());
return new CorsFilter(source);
}
}
SQL样例：
create database imooc_homepage_sc;
-- 用户信息表
create table if not exists `imooc_homepage_sc`.`homepage_user` (
`id` bigint(20) not null auto_increment comment '自增ID',
`username` varchar(128) not null default '' comment '用户名',
`email` varchar(128) not null default '' comment '用户邮箱',
`create_time` datetime not null default '1970-01-01 08:00:00' comment '创建时间',
`update_time` datetime not null default '1970-01-01 08:00:00' comment '更新时间',
primary key(`id`),
unique key `key_username` (`username`)
)engine=InnoDB auto_increment=1 default charset=utf8 row_format=compact comment='用户信息表'；
-- 用户课程表
create table if not exists `imooc_homepage_sc`.`homepage_user_course` (
`id` bigint(20) not null auto_increment comment '自增ID',
`user_id` bigint(20) not null default 0 comment '用户 ID',
`course_id` bigint(20) not null default 0 comment '课程 ID',
`create_time` datetime not null default '1970-01-01 08:00:00' comment '创建时间',
`update_time` datetime not null default '1970-01-01 08:00:00' comment '更新时间',
primary key(`id`),
unique key `key_user_course` (`user_id`, `course_id`)
)engine=InnoDB auto_increment=1 default charset=utf8 row_format=compact comment='用户课程表'；
-- 课程表
create table if not exists `imooc_homepage_sc`.`homepage_course` (
`id` bigint(20) not null auto_increment comment '自增ID',
`course_name` varchar(128) not null default '' comment '课程名称',
`course_type` varchar(128) not null default '' comment '课程类型',
`course_icon` varchar(128) not null default '' comment '课程图标',
`course_intro` varchar(128) not null default '' comment '课程介绍',
`create_time` datetime not null default '1970-01-01 08:00:00' comment '创建时间',
`update_time` datetime not null default '1970-01-01 08:00:00' comment '更新时间',
primary key(`id`),
unique key `key_course_name` (`course_name`)
)engine=InnoDB auto_increment=1 default charset=utf8 row_format=compact comment='课程表'；
未完待续~
