201206030/novel-cloud
1
0
Fork 0
mirror of https://github.com/201206030/novel-cloud.git synced 2025-06-24 14:06:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

模块构建完成

Browse Source
This commit is contained in:
xiongxiaoyang
2020-05-28 02:12:24 +08:00
parent 93189d92cc
commit c6e6a1df9f
170 changed files with 14777 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
novel-book/book-service/pom.xml Normal file
View File

@ -0,0 +1,44 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>novel-book</artifactId>
<groupId>com.java2nb.novel</groupId>
<version>1.0.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>book-service</artifactId>
<dependencies>
<dependency>
<groupId>com.java2nb.novel</groupId>
<artifactId>book-api</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-netflix-hystrix</artifactId>
</dependency>
</dependencies>
</project>

20
novel-book/book-service/src/main/java/com/java2nb/novel/BookApplication.java Normal file
View File

@ -0,0 +1,20 @@
package com.java2nb.novel;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* 小说微服务启动器
* @author xiongxiaoyang
* @version 1.0
* @since 2020/5/27
*/
@SpringBootApplication
@EnableFeignClients
public class BookApplication {
public static void main(String[] args) {
SpringApplication.run(BookApplication.class);
}
}

60
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookCategoryDynamicSqlSupport.java Normal file
View File

@ -0,0 +1,60 @@
package com.java2nb.novel.book.mapper;
import org.mybatis.dynamic.sql.SqlColumn;
import org.mybatis.dynamic.sql.SqlTable;
import javax.annotation.Generated;
import java.sql.JDBCType;
import java.util.Date;
public final class BookCategoryDynamicSqlSupport {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final BookCategory bookCategory = new BookCategory();
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Integer> id = bookCategory.id;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> workDirection = bookCategory.workDirection;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> name = bookCategory.name;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> sort = bookCategory.sort;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> createUserId = bookCategory.createUserId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> createTime = bookCategory.createTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> updateUserId = bookCategory.updateUserId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> updateTime = bookCategory.updateTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final class BookCategory extends SqlTable {
public final SqlColumn<Integer> id = column("id", JDBCType.INTEGER);
public final SqlColumn<Byte> workDirection = column("work_direction", JDBCType.TINYINT);
public final SqlColumn<String> name = column("name", JDBCType.VARCHAR);
public final SqlColumn<Byte> sort = column("sort", JDBCType.TINYINT);
public final SqlColumn<Long> createUserId = column("create_user_id", JDBCType.BIGINT);
public final SqlColumn<Date> createTime = column("create_time", JDBCType.TIMESTAMP);
public final SqlColumn<Long> updateUserId = column("update_user_id", JDBCType.BIGINT);
public final SqlColumn<Date> updateTime = column("update_time", JDBCType.TIMESTAMP);
public BookCategory() {
super("book_category");
}
}
}

191
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookCategoryMapper.java Normal file
View File

@ -0,0 +1,191 @@
package com.java2nb.novel.book.mapper;
import com.java2nb.novel.book.entity.BookCategory;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.dynamic.sql.SqlBuilder;
import org.mybatis.dynamic.sql.delete.DeleteDSL;
import org.mybatis.dynamic.sql.delete.MyBatis3DeleteModelAdapter;
import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
import org.mybatis.dynamic.sql.render.RenderingStrategy;
import org.mybatis.dynamic.sql.select.MyBatis3SelectModelAdapter;
import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
import org.mybatis.dynamic.sql.select.SelectDSL;
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
import org.mybatis.dynamic.sql.update.MyBatis3UpdateModelAdapter;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
import javax.annotation.Generated;
import java.util.List;
import static com.java2nb.novel.book.mapper.BookCategoryDynamicSqlSupport.*;
import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
@Mapper
public interface BookCategoryMapper {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
long count(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@DeleteProvider(type=SqlProviderAdapter.class, method="delete")
int delete(DeleteStatementProvider deleteStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@InsertProvider(type=SqlProviderAdapter.class, method="insert")
int insert(InsertStatementProvider<BookCategory> insertStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@ResultMap("BookCategoryResult")
BookCategory selectOne(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@Results(id="BookCategoryResult", value = {
@Result(column="id", property="id", jdbcType=JdbcType.INTEGER, id=true),
@Result(column="work_direction", property="workDirection", jdbcType=JdbcType.TINYINT),
@Result(column="name", property="name", jdbcType=JdbcType.VARCHAR),
@Result(column="sort", property="sort", jdbcType=JdbcType.TINYINT),
@Result(column="create_user_id", property="createUserId", jdbcType=JdbcType.BIGINT),
@Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP),
@Result(column="update_user_id", property="updateUserId", jdbcType=JdbcType.BIGINT),
@Result(column="update_time", property="updateTime", jdbcType=JdbcType.TIMESTAMP)
})
List<BookCategory> selectMany(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@UpdateProvider(type=SqlProviderAdapter.class, method="update")
int update(UpdateStatementProvider updateStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<Long>> countByExample() {
return SelectDSL.selectWithMapper(this::count, SqlBuilder.count())
.from(bookCategory);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default DeleteDSL<MyBatis3DeleteModelAdapter<Integer>> deleteByExample() {
return DeleteDSL.deleteFromWithMapper(this::delete, bookCategory);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int deleteByPrimaryKey(Integer id_) {
return DeleteDSL.deleteFromWithMapper(this::delete, bookCategory)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insert(BookCategory record) {
return insert(SqlBuilder.insert(record)
.into(bookCategory)
.map(id).toProperty("id")
.map(workDirection).toProperty("workDirection")
.map(name).toProperty("name")
.map(sort).toProperty("sort")
.map(createUserId).toProperty("createUserId")
.map(createTime).toProperty("createTime")
.map(updateUserId).toProperty("updateUserId")
.map(updateTime).toProperty("updateTime")
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insertSelective(BookCategory record) {
return insert(SqlBuilder.insert(record)
.into(bookCategory)
.map(id).toPropertyWhenPresent("id", record::getId)
.map(workDirection).toPropertyWhenPresent("workDirection", record::getWorkDirection)
.map(name).toPropertyWhenPresent("name", record::getName)
.map(sort).toPropertyWhenPresent("sort", record::getSort)
.map(createUserId).toPropertyWhenPresent("createUserId", record::getCreateUserId)
.map(createTime).toPropertyWhenPresent("createTime", record::getCreateTime)
.map(updateUserId).toPropertyWhenPresent("updateUserId", record::getUpdateUserId)
.map(updateTime).toPropertyWhenPresent("updateTime", record::getUpdateTime)
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookCategory>>> selectByExample() {
return SelectDSL.selectWithMapper(this::selectMany, id, workDirection, name, sort, createUserId, createTime, updateUserId, updateTime)
.from(bookCategory);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookCategory>>> selectDistinctByExample() {
return SelectDSL.selectDistinctWithMapper(this::selectMany, id, workDirection, name, sort, createUserId, createTime, updateUserId, updateTime)
.from(bookCategory);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default BookCategory selectByPrimaryKey(Integer id_) {
return SelectDSL.selectWithMapper(this::selectOne, id, workDirection, name, sort, createUserId, createTime, updateUserId, updateTime)
.from(bookCategory)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExample(BookCategory record) {
return UpdateDSL.updateWithMapper(this::update, bookCategory)
.set(id).equalTo(record::getId)
.set(workDirection).equalTo(record::getWorkDirection)
.set(name).equalTo(record::getName)
.set(sort).equalTo(record::getSort)
.set(createUserId).equalTo(record::getCreateUserId)
.set(createTime).equalTo(record::getCreateTime)
.set(updateUserId).equalTo(record::getUpdateUserId)
.set(updateTime).equalTo(record::getUpdateTime);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExampleSelective(BookCategory record) {
return UpdateDSL.updateWithMapper(this::update, bookCategory)
.set(id).equalToWhenPresent(record::getId)
.set(workDirection).equalToWhenPresent(record::getWorkDirection)
.set(name).equalToWhenPresent(record::getName)
.set(sort).equalToWhenPresent(record::getSort)
.set(createUserId).equalToWhenPresent(record::getCreateUserId)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(updateUserId).equalToWhenPresent(record::getUpdateUserId)
.set(updateTime).equalToWhenPresent(record::getUpdateTime);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKey(BookCategory record) {
return UpdateDSL.updateWithMapper(this::update, bookCategory)
.set(workDirection).equalTo(record::getWorkDirection)
.set(name).equalTo(record::getName)
.set(sort).equalTo(record::getSort)
.set(createUserId).equalTo(record::getCreateUserId)
.set(createTime).equalTo(record::getCreateTime)
.set(updateUserId).equalTo(record::getUpdateUserId)
.set(updateTime).equalTo(record::getUpdateTime)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKeySelective(BookCategory record) {
return UpdateDSL.updateWithMapper(this::update, bookCategory)
.set(workDirection).equalToWhenPresent(record::getWorkDirection)
.set(name).equalToWhenPresent(record::getName)
.set(sort).equalToWhenPresent(record::getSort)
.set(createUserId).equalToWhenPresent(record::getCreateUserId)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(updateUserId).equalToWhenPresent(record::getUpdateUserId)
.set(updateTime).equalToWhenPresent(record::getUpdateTime)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
}

55
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookCommentDynamicSqlSupport.java Normal file
View File

@ -0,0 +1,55 @@
package com.java2nb.novel.book.mapper;
import org.mybatis.dynamic.sql.SqlColumn;
import org.mybatis.dynamic.sql.SqlTable;
import javax.annotation.Generated;
import java.sql.JDBCType;
import java.util.Date;
public final class BookCommentDynamicSqlSupport {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final BookComment bookComment = new BookComment();
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> id = bookComment.id;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> bookId = bookComment.bookId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> commentContent = bookComment.commentContent;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Integer> replyCount = bookComment.replyCount;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> auditStatus = bookComment.auditStatus;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> createTime = bookComment.createTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> createUserId = bookComment.createUserId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final class BookComment extends SqlTable {
public final SqlColumn<Long> id = column("id", JDBCType.BIGINT);
public final SqlColumn<Long> bookId = column("book_id", JDBCType.BIGINT);
public final SqlColumn<String> commentContent = column("comment_content", JDBCType.VARCHAR);
public final SqlColumn<Integer> replyCount = column("reply_count", JDBCType.INTEGER);
public final SqlColumn<Byte> auditStatus = column("audit_status", JDBCType.TINYINT);
public final SqlColumn<Date> createTime = column("create_time", JDBCType.TIMESTAMP);
public final SqlColumn<Long> createUserId = column("create_user_id", JDBCType.BIGINT);
public BookComment() {
super("book_comment");
}
}
}

184
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookCommentMapper.java Normal file
View File

@ -0,0 +1,184 @@
package com.java2nb.novel.book.mapper;
import com.java2nb.novel.book.entity.BookComment;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.dynamic.sql.SqlBuilder;
import org.mybatis.dynamic.sql.delete.DeleteDSL;
import org.mybatis.dynamic.sql.delete.MyBatis3DeleteModelAdapter;
import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
import org.mybatis.dynamic.sql.render.RenderingStrategy;
import org.mybatis.dynamic.sql.select.MyBatis3SelectModelAdapter;
import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
import org.mybatis.dynamic.sql.select.SelectDSL;
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
import org.mybatis.dynamic.sql.update.MyBatis3UpdateModelAdapter;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
import javax.annotation.Generated;
import java.util.List;
import static com.java2nb.novel.book.mapper.BookCommentDynamicSqlSupport.*;
import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
@Mapper
public interface BookCommentMapper {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
long count(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@DeleteProvider(type=SqlProviderAdapter.class, method="delete")
int delete(DeleteStatementProvider deleteStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@InsertProvider(type=SqlProviderAdapter.class, method="insert")
int insert(InsertStatementProvider<BookComment> insertStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@ResultMap("BookCommentResult")
BookComment selectOne(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@Results(id="BookCommentResult", value = {
@Result(column="id", property="id", jdbcType=JdbcType.BIGINT, id=true),
@Result(column="book_id", property="bookId", jdbcType=JdbcType.BIGINT),
@Result(column="comment_content", property="commentContent", jdbcType=JdbcType.VARCHAR),
@Result(column="reply_count", property="replyCount", jdbcType=JdbcType.INTEGER),
@Result(column="audit_status", property="auditStatus", jdbcType=JdbcType.TINYINT),
@Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP),
@Result(column="create_user_id", property="createUserId", jdbcType=JdbcType.BIGINT)
})
List<BookComment> selectMany(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@UpdateProvider(type=SqlProviderAdapter.class, method="update")
int update(UpdateStatementProvider updateStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<Long>> countByExample() {
return SelectDSL.selectWithMapper(this::count, SqlBuilder.count())
.from(bookComment);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default DeleteDSL<MyBatis3DeleteModelAdapter<Integer>> deleteByExample() {
return DeleteDSL.deleteFromWithMapper(this::delete, bookComment);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int deleteByPrimaryKey(Long id_) {
return DeleteDSL.deleteFromWithMapper(this::delete, bookComment)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insert(BookComment record) {
return insert(SqlBuilder.insert(record)
.into(bookComment)
.map(id).toProperty("id")
.map(bookId).toProperty("bookId")
.map(commentContent).toProperty("commentContent")
.map(replyCount).toProperty("replyCount")
.map(auditStatus).toProperty("auditStatus")
.map(createTime).toProperty("createTime")
.map(createUserId).toProperty("createUserId")
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insertSelective(BookComment record) {
return insert(SqlBuilder.insert(record)
.into(bookComment)
.map(id).toPropertyWhenPresent("id", record::getId)
.map(bookId).toPropertyWhenPresent("bookId", record::getBookId)
.map(commentContent).toPropertyWhenPresent("commentContent", record::getCommentContent)
.map(replyCount).toPropertyWhenPresent("replyCount", record::getReplyCount)
.map(auditStatus).toPropertyWhenPresent("auditStatus", record::getAuditStatus)
.map(createTime).toPropertyWhenPresent("createTime", record::getCreateTime)
.map(createUserId).toPropertyWhenPresent("createUserId", record::getCreateUserId)
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookComment>>> selectByExample() {
return SelectDSL.selectWithMapper(this::selectMany, id, bookId, commentContent, replyCount, auditStatus, createTime, createUserId)
.from(bookComment);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookComment>>> selectDistinctByExample() {
return SelectDSL.selectDistinctWithMapper(this::selectMany, id, bookId, commentContent, replyCount, auditStatus, createTime, createUserId)
.from(bookComment);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default BookComment selectByPrimaryKey(Long id_) {
return SelectDSL.selectWithMapper(this::selectOne, id, bookId, commentContent, replyCount, auditStatus, createTime, createUserId)
.from(bookComment)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExample(BookComment record) {
return UpdateDSL.updateWithMapper(this::update, bookComment)
.set(id).equalTo(record::getId)
.set(bookId).equalTo(record::getBookId)
.set(commentContent).equalTo(record::getCommentContent)
.set(replyCount).equalTo(record::getReplyCount)
.set(auditStatus).equalTo(record::getAuditStatus)
.set(createTime).equalTo(record::getCreateTime)
.set(createUserId).equalTo(record::getCreateUserId);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExampleSelective(BookComment record) {
return UpdateDSL.updateWithMapper(this::update, bookComment)
.set(id).equalToWhenPresent(record::getId)
.set(bookId).equalToWhenPresent(record::getBookId)
.set(commentContent).equalToWhenPresent(record::getCommentContent)
.set(replyCount).equalToWhenPresent(record::getReplyCount)
.set(auditStatus).equalToWhenPresent(record::getAuditStatus)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(createUserId).equalToWhenPresent(record::getCreateUserId);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKey(BookComment record) {
return UpdateDSL.updateWithMapper(this::update, bookComment)
.set(bookId).equalTo(record::getBookId)
.set(commentContent).equalTo(record::getCommentContent)
.set(replyCount).equalTo(record::getReplyCount)
.set(auditStatus).equalTo(record::getAuditStatus)
.set(createTime).equalTo(record::getCreateTime)
.set(createUserId).equalTo(record::getCreateUserId)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKeySelective(BookComment record) {
return UpdateDSL.updateWithMapper(this::update, bookComment)
.set(bookId).equalToWhenPresent(record::getBookId)
.set(commentContent).equalToWhenPresent(record::getCommentContent)
.set(replyCount).equalToWhenPresent(record::getReplyCount)
.set(auditStatus).equalToWhenPresent(record::getAuditStatus)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(createUserId).equalToWhenPresent(record::getCreateUserId)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
}

50
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookCommentReplyDynamicSqlSupport.java Normal file
View File

@ -0,0 +1,50 @@
package com.java2nb.novel.book.mapper;
import org.mybatis.dynamic.sql.SqlColumn;
import org.mybatis.dynamic.sql.SqlTable;
import javax.annotation.Generated;
import java.sql.JDBCType;
import java.util.Date;
public final class BookCommentReplyDynamicSqlSupport {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final BookCommentReply bookCommentReply = new BookCommentReply();
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> id = bookCommentReply.id;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> commentId = bookCommentReply.commentId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> replyContent = bookCommentReply.replyContent;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> auditStatus = bookCommentReply.auditStatus;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> createTime = bookCommentReply.createTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> createUserId = bookCommentReply.createUserId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final class BookCommentReply extends SqlTable {
public final SqlColumn<Long> id = column("id", JDBCType.BIGINT);
public final SqlColumn<Long> commentId = column("comment_id", JDBCType.BIGINT);
public final SqlColumn<String> replyContent = column("reply_content", JDBCType.VARCHAR);
public final SqlColumn<Byte> auditStatus = column("audit_status", JDBCType.TINYINT);
public final SqlColumn<Date> createTime = column("create_time", JDBCType.TIMESTAMP);
public final SqlColumn<Long> createUserId = column("create_user_id", JDBCType.BIGINT);
public BookCommentReply() {
super("book_comment_reply");
}
}
}

177
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookCommentReplyMapper.java Normal file
View File

@ -0,0 +1,177 @@
package com.java2nb.novel.book.mapper;
import com.java2nb.novel.book.entity.BookCommentReply;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.dynamic.sql.SqlBuilder;
import org.mybatis.dynamic.sql.delete.DeleteDSL;
import org.mybatis.dynamic.sql.delete.MyBatis3DeleteModelAdapter;
import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
import org.mybatis.dynamic.sql.render.RenderingStrategy;
import org.mybatis.dynamic.sql.select.MyBatis3SelectModelAdapter;
import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
import org.mybatis.dynamic.sql.select.SelectDSL;
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
import org.mybatis.dynamic.sql.update.MyBatis3UpdateModelAdapter;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
import javax.annotation.Generated;
import java.util.List;
import static com.java2nb.novel.book.mapper.BookCommentReplyDynamicSqlSupport.*;
import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
@Mapper
public interface BookCommentReplyMapper {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
long count(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@DeleteProvider(type=SqlProviderAdapter.class, method="delete")
int delete(DeleteStatementProvider deleteStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@InsertProvider(type=SqlProviderAdapter.class, method="insert")
int insert(InsertStatementProvider<BookCommentReply> insertStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@ResultMap("BookCommentReplyResult")
BookCommentReply selectOne(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@Results(id="BookCommentReplyResult", value = {
@Result(column="id", property="id", jdbcType=JdbcType.BIGINT, id=true),
@Result(column="comment_id", property="commentId", jdbcType=JdbcType.BIGINT),
@Result(column="reply_content", property="replyContent", jdbcType=JdbcType.VARCHAR),
@Result(column="audit_status", property="auditStatus", jdbcType=JdbcType.TINYINT),
@Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP),
@Result(column="create_user_id", property="createUserId", jdbcType=JdbcType.BIGINT)
})
List<BookCommentReply> selectMany(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@UpdateProvider(type=SqlProviderAdapter.class, method="update")
int update(UpdateStatementProvider updateStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<Long>> countByExample() {
return SelectDSL.selectWithMapper(this::count, SqlBuilder.count())
.from(bookCommentReply);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default DeleteDSL<MyBatis3DeleteModelAdapter<Integer>> deleteByExample() {
return DeleteDSL.deleteFromWithMapper(this::delete, bookCommentReply);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int deleteByPrimaryKey(Long id_) {
return DeleteDSL.deleteFromWithMapper(this::delete, bookCommentReply)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insert(BookCommentReply record) {
return insert(SqlBuilder.insert(record)
.into(bookCommentReply)
.map(id).toProperty("id")
.map(commentId).toProperty("commentId")
.map(replyContent).toProperty("replyContent")
.map(auditStatus).toProperty("auditStatus")
.map(createTime).toProperty("createTime")
.map(createUserId).toProperty("createUserId")
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insertSelective(BookCommentReply record) {
return insert(SqlBuilder.insert(record)
.into(bookCommentReply)
.map(id).toPropertyWhenPresent("id", record::getId)
.map(commentId).toPropertyWhenPresent("commentId", record::getCommentId)
.map(replyContent).toPropertyWhenPresent("replyContent", record::getReplyContent)
.map(auditStatus).toPropertyWhenPresent("auditStatus", record::getAuditStatus)
.map(createTime).toPropertyWhenPresent("createTime", record::getCreateTime)
.map(createUserId).toPropertyWhenPresent("createUserId", record::getCreateUserId)
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookCommentReply>>> selectByExample() {
return SelectDSL.selectWithMapper(this::selectMany, id, commentId, replyContent, auditStatus, createTime, createUserId)
.from(bookCommentReply);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookCommentReply>>> selectDistinctByExample() {
return SelectDSL.selectDistinctWithMapper(this::selectMany, id, commentId, replyContent, auditStatus, createTime, createUserId)
.from(bookCommentReply);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default BookCommentReply selectByPrimaryKey(Long id_) {
return SelectDSL.selectWithMapper(this::selectOne, id, commentId, replyContent, auditStatus, createTime, createUserId)
.from(bookCommentReply)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExample(BookCommentReply record) {
return UpdateDSL.updateWithMapper(this::update, bookCommentReply)
.set(id).equalTo(record::getId)
.set(commentId).equalTo(record::getCommentId)
.set(replyContent).equalTo(record::getReplyContent)
.set(auditStatus).equalTo(record::getAuditStatus)
.set(createTime).equalTo(record::getCreateTime)
.set(createUserId).equalTo(record::getCreateUserId);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExampleSelective(BookCommentReply record) {
return UpdateDSL.updateWithMapper(this::update, bookCommentReply)
.set(id).equalToWhenPresent(record::getId)
.set(commentId).equalToWhenPresent(record::getCommentId)
.set(replyContent).equalToWhenPresent(record::getReplyContent)
.set(auditStatus).equalToWhenPresent(record::getAuditStatus)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(createUserId).equalToWhenPresent(record::getCreateUserId);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKey(BookCommentReply record) {
return UpdateDSL.updateWithMapper(this::update, bookCommentReply)
.set(commentId).equalTo(record::getCommentId)
.set(replyContent).equalTo(record::getReplyContent)
.set(auditStatus).equalTo(record::getAuditStatus)
.set(createTime).equalTo(record::getCreateTime)
.set(createUserId).equalTo(record::getCreateUserId)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKeySelective(BookCommentReply record) {
return UpdateDSL.updateWithMapper(this::update, bookCommentReply)
.set(commentId).equalToWhenPresent(record::getCommentId)
.set(replyContent).equalToWhenPresent(record::getReplyContent)
.set(auditStatus).equalToWhenPresent(record::getAuditStatus)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(createUserId).equalToWhenPresent(record::getCreateUserId)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
}

34
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookContentDynamicSqlSupport.java Normal file
View File

@ -0,0 +1,34 @@
package com.java2nb.novel.book.mapper;
import org.mybatis.dynamic.sql.SqlColumn;
import org.mybatis.dynamic.sql.SqlTable;
import javax.annotation.Generated;
import java.sql.JDBCType;
public final class BookContentDynamicSqlSupport {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final BookContent bookContent = new BookContent();
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> id = bookContent.id;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> indexId = bookContent.indexId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> content = bookContent.content;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final class BookContent extends SqlTable {
public final SqlColumn<Long> id = column("id", JDBCType.BIGINT);
public final SqlColumn<Long> indexId = column("index_id", JDBCType.BIGINT);
public final SqlColumn<String> content = column("content", JDBCType.LONGVARCHAR);
public BookContent() {
super("book_content");
}
}
}

156
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookContentMapper.java Normal file
View File

@ -0,0 +1,156 @@
package com.java2nb.novel.book.mapper;
import com.java2nb.novel.book.entity.BookContent;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.dynamic.sql.SqlBuilder;
import org.mybatis.dynamic.sql.delete.DeleteDSL;
import org.mybatis.dynamic.sql.delete.MyBatis3DeleteModelAdapter;
import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
import org.mybatis.dynamic.sql.render.RenderingStrategy;
import org.mybatis.dynamic.sql.select.MyBatis3SelectModelAdapter;
import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
import org.mybatis.dynamic.sql.select.SelectDSL;
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
import org.mybatis.dynamic.sql.update.MyBatis3UpdateModelAdapter;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
import javax.annotation.Generated;
import java.util.List;
import static com.java2nb.novel.book.mapper.BookContentDynamicSqlSupport.*;
import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
@Mapper
public interface BookContentMapper {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
long count(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@DeleteProvider(type=SqlProviderAdapter.class, method="delete")
int delete(DeleteStatementProvider deleteStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@InsertProvider(type=SqlProviderAdapter.class, method="insert")
int insert(InsertStatementProvider<BookContent> insertStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@ResultMap("BookContentResult")
BookContent selectOne(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@Results(id="BookContentResult", value = {
@Result(column="id", property="id", jdbcType=JdbcType.BIGINT, id=true),
@Result(column="index_id", property="indexId", jdbcType=JdbcType.BIGINT),
@Result(column="content", property="content", jdbcType=JdbcType.LONGVARCHAR)
})
List<BookContent> selectMany(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@UpdateProvider(type=SqlProviderAdapter.class, method="update")
int update(UpdateStatementProvider updateStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<Long>> countByExample() {
return SelectDSL.selectWithMapper(this::count, SqlBuilder.count())
.from(bookContent);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default DeleteDSL<MyBatis3DeleteModelAdapter<Integer>> deleteByExample() {
return DeleteDSL.deleteFromWithMapper(this::delete, bookContent);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int deleteByPrimaryKey(Long id_) {
return DeleteDSL.deleteFromWithMapper(this::delete, bookContent)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insert(BookContent record) {
return insert(SqlBuilder.insert(record)
.into(bookContent)
.map(id).toProperty("id")
.map(indexId).toProperty("indexId")
.map(content).toProperty("content")
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insertSelective(BookContent record) {
return insert(SqlBuilder.insert(record)
.into(bookContent)
.map(id).toPropertyWhenPresent("id", record::getId)
.map(indexId).toPropertyWhenPresent("indexId", record::getIndexId)
.map(content).toPropertyWhenPresent("content", record::getContent)
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookContent>>> selectByExample() {
return SelectDSL.selectWithMapper(this::selectMany, id, indexId, content)
.from(bookContent);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookContent>>> selectDistinctByExample() {
return SelectDSL.selectDistinctWithMapper(this::selectMany, id, indexId, content)
.from(bookContent);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default BookContent selectByPrimaryKey(Long id_) {
return SelectDSL.selectWithMapper(this::selectOne, id, indexId, content)
.from(bookContent)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExample(BookContent record) {
return UpdateDSL.updateWithMapper(this::update, bookContent)
.set(id).equalTo(record::getId)
.set(indexId).equalTo(record::getIndexId)
.set(content).equalTo(record::getContent);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExampleSelective(BookContent record) {
return UpdateDSL.updateWithMapper(this::update, bookContent)
.set(id).equalToWhenPresent(record::getId)
.set(indexId).equalToWhenPresent(record::getIndexId)
.set(content).equalToWhenPresent(record::getContent);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKey(BookContent record) {
return UpdateDSL.updateWithMapper(this::update, bookContent)
.set(indexId).equalTo(record::getIndexId)
.set(content).equalTo(record::getContent)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKeySelective(BookContent record) {
return UpdateDSL.updateWithMapper(this::update, bookContent)
.set(indexId).equalToWhenPresent(record::getIndexId)
.set(content).equalToWhenPresent(record::getContent)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
}

145
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookDynamicSqlSupport.java Normal file
View File

@ -0,0 +1,145 @@
package com.java2nb.novel.book.mapper;
import org.mybatis.dynamic.sql.SqlColumn;
import org.mybatis.dynamic.sql.SqlTable;
import javax.annotation.Generated;
import java.sql.JDBCType;
import java.util.Date;
public final class BookDynamicSqlSupport {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final Book book = new Book();
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> id = book.id;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> workDirection = book.workDirection;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Integer> catId = book.catId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> catName = book.catName;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> picUrl = book.picUrl;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> bookName = book.bookName;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> authorId = book.authorId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> authorName = book.authorName;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> bookDesc = book.bookDesc;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Float> score = book.score;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> bookStatus = book.bookStatus;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> visitCount = book.visitCount;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Integer> wordCount = book.wordCount;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Integer> commentCount = book.commentCount;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> lastIndexId = book.lastIndexId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> lastIndexName = book.lastIndexName;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> lastIndexUpdateTime = book.lastIndexUpdateTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> isVip = book.isVip;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> status = book.status;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> updateTime = book.updateTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> createTime = book.createTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Integer> crawlSourceId = book.crawlSourceId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> crawlBookId = book.crawlBookId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> crawlLastTime = book.crawlLastTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> crawlIsStop = book.crawlIsStop;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final class Book extends SqlTable {
public final SqlColumn<Long> id = column("id", JDBCType.BIGINT);
public final SqlColumn<Byte> workDirection = column("work_direction", JDBCType.TINYINT);
public final SqlColumn<Integer> catId = column("cat_id", JDBCType.INTEGER);
public final SqlColumn<String> catName = column("cat_name", JDBCType.VARCHAR);
public final SqlColumn<String> picUrl = column("pic_url", JDBCType.VARCHAR);
public final SqlColumn<String> bookName = column("book_name", JDBCType.VARCHAR);
public final SqlColumn<Long> authorId = column("author_id", JDBCType.BIGINT);
public final SqlColumn<String> authorName = column("author_name", JDBCType.VARCHAR);
public final SqlColumn<String> bookDesc = column("book_desc", JDBCType.VARCHAR);
public final SqlColumn<Float> score = column("score", JDBCType.REAL);
public final SqlColumn<Byte> bookStatus = column("book_status", JDBCType.TINYINT);
public final SqlColumn<Long> visitCount = column("visit_count", JDBCType.BIGINT);
public final SqlColumn<Integer> wordCount = column("word_count", JDBCType.INTEGER);
public final SqlColumn<Integer> commentCount = column("comment_count", JDBCType.INTEGER);
public final SqlColumn<Long> lastIndexId = column("last_index_id", JDBCType.BIGINT);
public final SqlColumn<String> lastIndexName = column("last_index_name", JDBCType.VARCHAR);
public final SqlColumn<Date> lastIndexUpdateTime = column("last_index_update_time", JDBCType.TIMESTAMP);
public final SqlColumn<Byte> isVip = column("is_vip", JDBCType.TINYINT);
public final SqlColumn<Byte> status = column("status", JDBCType.TINYINT);
public final SqlColumn<Date> updateTime = column("update_time", JDBCType.TIMESTAMP);
public final SqlColumn<Date> createTime = column("create_time", JDBCType.TIMESTAMP);
public final SqlColumn<Integer> crawlSourceId = column("crawl_source_id", JDBCType.INTEGER);
public final SqlColumn<String> crawlBookId = column("crawl_book_id", JDBCType.VARCHAR);
public final SqlColumn<Date> crawlLastTime = column("crawl_last_time", JDBCType.TIMESTAMP);
public final SqlColumn<Byte> crawlIsStop = column("crawl_is_stop", JDBCType.TINYINT);
public Book() {
super("book");
}
}
}

60
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookIndexDynamicSqlSupport.java Normal file
View File

@ -0,0 +1,60 @@
package com.java2nb.novel.book.mapper;
import org.mybatis.dynamic.sql.SqlColumn;
import org.mybatis.dynamic.sql.SqlTable;
import javax.annotation.Generated;
import java.sql.JDBCType;
import java.util.Date;
public final class BookIndexDynamicSqlSupport {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final BookIndex bookIndex = new BookIndex();
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> id = bookIndex.id;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Long> bookId = bookIndex.bookId;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Integer> indexNum = bookIndex.indexNum;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<String> indexName = bookIndex.indexName;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Integer> wordCount = bookIndex.wordCount;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Byte> isVip = bookIndex.isVip;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> createTime = bookIndex.createTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final SqlColumn<Date> updateTime = bookIndex.updateTime;
@Generated("org.mybatis.generator.api.MyBatisGenerator")
public static final class BookIndex extends SqlTable {
public final SqlColumn<Long> id = column("id", JDBCType.BIGINT);
public final SqlColumn<Long> bookId = column("book_id", JDBCType.BIGINT);
public final SqlColumn<Integer> indexNum = column("index_num", JDBCType.INTEGER);
public final SqlColumn<String> indexName = column("index_name", JDBCType.VARCHAR);
public final SqlColumn<Integer> wordCount = column("word_count", JDBCType.INTEGER);
public final SqlColumn<Byte> isVip = column("is_vip", JDBCType.TINYINT);
public final SqlColumn<Date> createTime = column("create_time", JDBCType.TIMESTAMP);
public final SqlColumn<Date> updateTime = column("update_time", JDBCType.TIMESTAMP);
public BookIndex() {
super("book_index");
}
}
}

191
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookIndexMapper.java Normal file
View File

@ -0,0 +1,191 @@
package com.java2nb.novel.book.mapper;
import com.java2nb.novel.book.entity.BookIndex;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.dynamic.sql.SqlBuilder;
import org.mybatis.dynamic.sql.delete.DeleteDSL;
import org.mybatis.dynamic.sql.delete.MyBatis3DeleteModelAdapter;
import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
import org.mybatis.dynamic.sql.render.RenderingStrategy;
import org.mybatis.dynamic.sql.select.MyBatis3SelectModelAdapter;
import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
import org.mybatis.dynamic.sql.select.SelectDSL;
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
import org.mybatis.dynamic.sql.update.MyBatis3UpdateModelAdapter;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
import javax.annotation.Generated;
import java.util.List;
import static com.java2nb.novel.book.mapper.BookIndexDynamicSqlSupport.*;
import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
@Mapper
public interface BookIndexMapper {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
long count(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@DeleteProvider(type=SqlProviderAdapter.class, method="delete")
int delete(DeleteStatementProvider deleteStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@InsertProvider(type=SqlProviderAdapter.class, method="insert")
int insert(InsertStatementProvider<BookIndex> insertStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@ResultMap("BookIndexResult")
BookIndex selectOne(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@Results(id="BookIndexResult", value = {
@Result(column="id", property="id", jdbcType=JdbcType.BIGINT, id=true),
@Result(column="book_id", property="bookId", jdbcType=JdbcType.BIGINT),
@Result(column="index_num", property="indexNum", jdbcType=JdbcType.INTEGER),
@Result(column="index_name", property="indexName", jdbcType=JdbcType.VARCHAR),
@Result(column="word_count", property="wordCount", jdbcType=JdbcType.INTEGER),
@Result(column="is_vip", property="isVip", jdbcType=JdbcType.TINYINT),
@Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP),
@Result(column="update_time", property="updateTime", jdbcType=JdbcType.TIMESTAMP)
})
List<BookIndex> selectMany(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@UpdateProvider(type=SqlProviderAdapter.class, method="update")
int update(UpdateStatementProvider updateStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<Long>> countByExample() {
return SelectDSL.selectWithMapper(this::count, SqlBuilder.count())
.from(bookIndex);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default DeleteDSL<MyBatis3DeleteModelAdapter<Integer>> deleteByExample() {
return DeleteDSL.deleteFromWithMapper(this::delete, bookIndex);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int deleteByPrimaryKey(Long id_) {
return DeleteDSL.deleteFromWithMapper(this::delete, bookIndex)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insert(BookIndex record) {
return insert(SqlBuilder.insert(record)
.into(bookIndex)
.map(id).toProperty("id")
.map(bookId).toProperty("bookId")
.map(indexNum).toProperty("indexNum")
.map(indexName).toProperty("indexName")
.map(wordCount).toProperty("wordCount")
.map(isVip).toProperty("isVip")
.map(createTime).toProperty("createTime")
.map(updateTime).toProperty("updateTime")
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insertSelective(BookIndex record) {
return insert(SqlBuilder.insert(record)
.into(bookIndex)
.map(id).toPropertyWhenPresent("id", record::getId)
.map(bookId).toPropertyWhenPresent("bookId", record::getBookId)
.map(indexNum).toPropertyWhenPresent("indexNum", record::getIndexNum)
.map(indexName).toPropertyWhenPresent("indexName", record::getIndexName)
.map(wordCount).toPropertyWhenPresent("wordCount", record::getWordCount)
.map(isVip).toPropertyWhenPresent("isVip", record::getIsVip)
.map(createTime).toPropertyWhenPresent("createTime", record::getCreateTime)
.map(updateTime).toPropertyWhenPresent("updateTime", record::getUpdateTime)
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookIndex>>> selectByExample() {
return SelectDSL.selectWithMapper(this::selectMany, id, bookId, indexNum, indexName, wordCount, isVip, createTime, updateTime)
.from(bookIndex);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<BookIndex>>> selectDistinctByExample() {
return SelectDSL.selectDistinctWithMapper(this::selectMany, id, bookId, indexNum, indexName, wordCount, isVip, createTime, updateTime)
.from(bookIndex);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default BookIndex selectByPrimaryKey(Long id_) {
return SelectDSL.selectWithMapper(this::selectOne, id, bookId, indexNum, indexName, wordCount, isVip, createTime, updateTime)
.from(bookIndex)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExample(BookIndex record) {
return UpdateDSL.updateWithMapper(this::update, bookIndex)
.set(id).equalTo(record::getId)
.set(bookId).equalTo(record::getBookId)
.set(indexNum).equalTo(record::getIndexNum)
.set(indexName).equalTo(record::getIndexName)
.set(wordCount).equalTo(record::getWordCount)
.set(isVip).equalTo(record::getIsVip)
.set(createTime).equalTo(record::getCreateTime)
.set(updateTime).equalTo(record::getUpdateTime);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExampleSelective(BookIndex record) {
return UpdateDSL.updateWithMapper(this::update, bookIndex)
.set(id).equalToWhenPresent(record::getId)
.set(bookId).equalToWhenPresent(record::getBookId)
.set(indexNum).equalToWhenPresent(record::getIndexNum)
.set(indexName).equalToWhenPresent(record::getIndexName)
.set(wordCount).equalToWhenPresent(record::getWordCount)
.set(isVip).equalToWhenPresent(record::getIsVip)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(updateTime).equalToWhenPresent(record::getUpdateTime);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKey(BookIndex record) {
return UpdateDSL.updateWithMapper(this::update, bookIndex)
.set(bookId).equalTo(record::getBookId)
.set(indexNum).equalTo(record::getIndexNum)
.set(indexName).equalTo(record::getIndexName)
.set(wordCount).equalTo(record::getWordCount)
.set(isVip).equalTo(record::getIsVip)
.set(createTime).equalTo(record::getCreateTime)
.set(updateTime).equalTo(record::getUpdateTime)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKeySelective(BookIndex record) {
return UpdateDSL.updateWithMapper(this::update, bookIndex)
.set(bookId).equalToWhenPresent(record::getBookId)
.set(indexNum).equalToWhenPresent(record::getIndexNum)
.set(indexName).equalToWhenPresent(record::getIndexName)
.set(wordCount).equalToWhenPresent(record::getWordCount)
.set(isVip).equalToWhenPresent(record::getIsVip)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(updateTime).equalToWhenPresent(record::getUpdateTime)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
}

310
novel-book/book-service/src/main/java/com/java2nb/novel/book/mapper/BookMapper.java Normal file
View File

@ -0,0 +1,310 @@
package com.java2nb.novel.book.mapper;
import com.java2nb.novel.book.entity.Book;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.dynamic.sql.SqlBuilder;
import org.mybatis.dynamic.sql.delete.DeleteDSL;
import org.mybatis.dynamic.sql.delete.MyBatis3DeleteModelAdapter;
import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
import org.mybatis.dynamic.sql.render.RenderingStrategy;
import org.mybatis.dynamic.sql.select.MyBatis3SelectModelAdapter;
import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
import org.mybatis.dynamic.sql.select.SelectDSL;
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
import org.mybatis.dynamic.sql.update.MyBatis3UpdateModelAdapter;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
import javax.annotation.Generated;
import java.util.List;
import static com.java2nb.novel.book.mapper.BookDynamicSqlSupport.*;
import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
@Mapper
public interface BookMapper {
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
long count(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@DeleteProvider(type=SqlProviderAdapter.class, method="delete")
int delete(DeleteStatementProvider deleteStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@InsertProvider(type=SqlProviderAdapter.class, method="insert")
int insert(InsertStatementProvider<Book> insertStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@ResultMap("BookResult")
Book selectOne(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@SelectProvider(type=SqlProviderAdapter.class, method="select")
@Results(id="BookResult", value = {
@Result(column="id", property="id", jdbcType=JdbcType.BIGINT, id=true),
@Result(column="work_direction", property="workDirection", jdbcType=JdbcType.TINYINT),
@Result(column="cat_id", property="catId", jdbcType=JdbcType.INTEGER),
@Result(column="cat_name", property="catName", jdbcType=JdbcType.VARCHAR),
@Result(column="pic_url", property="picUrl", jdbcType=JdbcType.VARCHAR),
@Result(column="book_name", property="bookName", jdbcType=JdbcType.VARCHAR),
@Result(column="author_id", property="authorId", jdbcType=JdbcType.BIGINT),
@Result(column="author_name", property="authorName", jdbcType=JdbcType.VARCHAR),
@Result(column="book_desc", property="bookDesc", jdbcType=JdbcType.VARCHAR),
@Result(column="score", property="score", jdbcType=JdbcType.REAL),
@Result(column="book_status", property="bookStatus", jdbcType=JdbcType.TINYINT),
@Result(column="visit_count", property="visitCount", jdbcType=JdbcType.BIGINT),
@Result(column="word_count", property="wordCount", jdbcType=JdbcType.INTEGER),
@Result(column="comment_count", property="commentCount", jdbcType=JdbcType.INTEGER),
@Result(column="last_index_id", property="lastIndexId", jdbcType=JdbcType.BIGINT),
@Result(column="last_index_name", property="lastIndexName", jdbcType=JdbcType.VARCHAR),
@Result(column="last_index_update_time", property="lastIndexUpdateTime", jdbcType=JdbcType.TIMESTAMP),
@Result(column="is_vip", property="isVip", jdbcType=JdbcType.TINYINT),
@Result(column="status", property="status", jdbcType=JdbcType.TINYINT),
@Result(column="update_time", property="updateTime", jdbcType=JdbcType.TIMESTAMP),
@Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP),
@Result(column="crawl_source_id", property="crawlSourceId", jdbcType=JdbcType.INTEGER),
@Result(column="crawl_book_id", property="crawlBookId", jdbcType=JdbcType.VARCHAR),
@Result(column="crawl_last_time", property="crawlLastTime", jdbcType=JdbcType.TIMESTAMP),
@Result(column="crawl_is_stop", property="crawlIsStop", jdbcType=JdbcType.TINYINT)
})
List<Book> selectMany(SelectStatementProvider selectStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
@UpdateProvider(type=SqlProviderAdapter.class, method="update")
int update(UpdateStatementProvider updateStatement);
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<Long>> countByExample() {
return SelectDSL.selectWithMapper(this::count, SqlBuilder.count())
.from(book);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default DeleteDSL<MyBatis3DeleteModelAdapter<Integer>> deleteByExample() {
return DeleteDSL.deleteFromWithMapper(this::delete, book);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int deleteByPrimaryKey(Long id_) {
return DeleteDSL.deleteFromWithMapper(this::delete, book)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insert(Book record) {
return insert(SqlBuilder.insert(record)
.into(book)
.map(id).toProperty("id")
.map(workDirection).toProperty("workDirection")
.map(catId).toProperty("catId")
.map(catName).toProperty("catName")
.map(picUrl).toProperty("picUrl")
.map(bookName).toProperty("bookName")
.map(authorId).toProperty("authorId")
.map(authorName).toProperty("authorName")
.map(bookDesc).toProperty("bookDesc")
.map(score).toProperty("score")
.map(bookStatus).toProperty("bookStatus")
.map(visitCount).toProperty("visitCount")
.map(wordCount).toProperty("wordCount")
.map(commentCount).toProperty("commentCount")
.map(lastIndexId).toProperty("lastIndexId")
.map(lastIndexName).toProperty("lastIndexName")
.map(lastIndexUpdateTime).toProperty("lastIndexUpdateTime")
.map(isVip).toProperty("isVip")
.map(status).toProperty("status")
.map(updateTime).toProperty("updateTime")
.map(createTime).toProperty("createTime")
.map(crawlSourceId).toProperty("crawlSourceId")
.map(crawlBookId).toProperty("crawlBookId")
.map(crawlLastTime).toProperty("crawlLastTime")
.map(crawlIsStop).toProperty("crawlIsStop")
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int insertSelective(Book record) {
return insert(SqlBuilder.insert(record)
.into(book)
.map(id).toPropertyWhenPresent("id", record::getId)
.map(workDirection).toPropertyWhenPresent("workDirection", record::getWorkDirection)
.map(catId).toPropertyWhenPresent("catId", record::getCatId)
.map(catName).toPropertyWhenPresent("catName", record::getCatName)
.map(picUrl).toPropertyWhenPresent("picUrl", record::getPicUrl)
.map(bookName).toPropertyWhenPresent("bookName", record::getBookName)
.map(authorId).toPropertyWhenPresent("authorId", record::getAuthorId)
.map(authorName).toPropertyWhenPresent("authorName", record::getAuthorName)
.map(bookDesc).toPropertyWhenPresent("bookDesc", record::getBookDesc)
.map(score).toPropertyWhenPresent("score", record::getScore)
.map(bookStatus).toPropertyWhenPresent("bookStatus", record::getBookStatus)
.map(visitCount).toPropertyWhenPresent("visitCount", record::getVisitCount)
.map(wordCount).toPropertyWhenPresent("wordCount", record::getWordCount)
.map(commentCount).toPropertyWhenPresent("commentCount", record::getCommentCount)
.map(lastIndexId).toPropertyWhenPresent("lastIndexId", record::getLastIndexId)
.map(lastIndexName).toPropertyWhenPresent("lastIndexName", record::getLastIndexName)
.map(lastIndexUpdateTime).toPropertyWhenPresent("lastIndexUpdateTime", record::getLastIndexUpdateTime)
.map(isVip).toPropertyWhenPresent("isVip", record::getIsVip)
.map(status).toPropertyWhenPresent("status", record::getStatus)
.map(updateTime).toPropertyWhenPresent("updateTime", record::getUpdateTime)
.map(createTime).toPropertyWhenPresent("createTime", record::getCreateTime)
.map(crawlSourceId).toPropertyWhenPresent("crawlSourceId", record::getCrawlSourceId)
.map(crawlBookId).toPropertyWhenPresent("crawlBookId", record::getCrawlBookId)
.map(crawlLastTime).toPropertyWhenPresent("crawlLastTime", record::getCrawlLastTime)
.map(crawlIsStop).toPropertyWhenPresent("crawlIsStop", record::getCrawlIsStop)
.build()
.render(RenderingStrategy.MYBATIS3));
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<Book>>> selectByExample() {
return SelectDSL.selectWithMapper(this::selectMany, id, workDirection, catId, catName, picUrl, bookName, authorId, authorName, bookDesc, score, bookStatus, visitCount, wordCount, commentCount, lastIndexId, lastIndexName, lastIndexUpdateTime, isVip, status, updateTime, createTime, crawlSourceId, crawlBookId, crawlLastTime, crawlIsStop)
.from(book);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<Book>>> selectDistinctByExample() {
return SelectDSL.selectDistinctWithMapper(this::selectMany, id, workDirection, catId, catName, picUrl, bookName, authorId, authorName, bookDesc, score, bookStatus, visitCount, wordCount, commentCount, lastIndexId, lastIndexName, lastIndexUpdateTime, isVip, status, updateTime, createTime, crawlSourceId, crawlBookId, crawlLastTime, crawlIsStop)
.from(book);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default Book selectByPrimaryKey(Long id_) {
return SelectDSL.selectWithMapper(this::selectOne, id, workDirection, catId, catName, picUrl, bookName, authorId, authorName, bookDesc, score, bookStatus, visitCount, wordCount, commentCount, lastIndexId, lastIndexName, lastIndexUpdateTime, isVip, status, updateTime, createTime, crawlSourceId, crawlBookId, crawlLastTime, crawlIsStop)
.from(book)
.where(id, isEqualTo(id_))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExample(Book record) {
return UpdateDSL.updateWithMapper(this::update, book)
.set(id).equalTo(record::getId)
.set(workDirection).equalTo(record::getWorkDirection)
.set(catId).equalTo(record::getCatId)
.set(catName).equalTo(record::getCatName)
.set(picUrl).equalTo(record::getPicUrl)
.set(bookName).equalTo(record::getBookName)
.set(authorId).equalTo(record::getAuthorId)
.set(authorName).equalTo(record::getAuthorName)
.set(bookDesc).equalTo(record::getBookDesc)
.set(score).equalTo(record::getScore)
.set(bookStatus).equalTo(record::getBookStatus)
.set(visitCount).equalTo(record::getVisitCount)
.set(wordCount).equalTo(record::getWordCount)
.set(commentCount).equalTo(record::getCommentCount)
.set(lastIndexId).equalTo(record::getLastIndexId)
.set(lastIndexName).equalTo(record::getLastIndexName)
.set(lastIndexUpdateTime).equalTo(record::getLastIndexUpdateTime)
.set(isVip).equalTo(record::getIsVip)
.set(status).equalTo(record::getStatus)
.set(updateTime).equalTo(record::getUpdateTime)
.set(createTime).equalTo(record::getCreateTime)
.set(crawlSourceId).equalTo(record::getCrawlSourceId)
.set(crawlBookId).equalTo(record::getCrawlBookId)
.set(crawlLastTime).equalTo(record::getCrawlLastTime)
.set(crawlIsStop).equalTo(record::getCrawlIsStop);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExampleSelective(Book record) {
return UpdateDSL.updateWithMapper(this::update, book)
.set(id).equalToWhenPresent(record::getId)
.set(workDirection).equalToWhenPresent(record::getWorkDirection)
.set(catId).equalToWhenPresent(record::getCatId)
.set(catName).equalToWhenPresent(record::getCatName)
.set(picUrl).equalToWhenPresent(record::getPicUrl)
.set(bookName).equalToWhenPresent(record::getBookName)
.set(authorId).equalToWhenPresent(record::getAuthorId)
.set(authorName).equalToWhenPresent(record::getAuthorName)
.set(bookDesc).equalToWhenPresent(record::getBookDesc)
.set(score).equalToWhenPresent(record::getScore)
.set(bookStatus).equalToWhenPresent(record::getBookStatus)
.set(visitCount).equalToWhenPresent(record::getVisitCount)
.set(wordCount).equalToWhenPresent(record::getWordCount)
.set(commentCount).equalToWhenPresent(record::getCommentCount)
.set(lastIndexId).equalToWhenPresent(record::getLastIndexId)
.set(lastIndexName).equalToWhenPresent(record::getLastIndexName)
.set(lastIndexUpdateTime).equalToWhenPresent(record::getLastIndexUpdateTime)
.set(isVip).equalToWhenPresent(record::getIsVip)
.set(status).equalToWhenPresent(record::getStatus)
.set(updateTime).equalToWhenPresent(record::getUpdateTime)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(crawlSourceId).equalToWhenPresent(record::getCrawlSourceId)
.set(crawlBookId).equalToWhenPresent(record::getCrawlBookId)
.set(crawlLastTime).equalToWhenPresent(record::getCrawlLastTime)
.set(crawlIsStop).equalToWhenPresent(record::getCrawlIsStop);
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKey(Book record) {
return UpdateDSL.updateWithMapper(this::update, book)
.set(workDirection).equalTo(record::getWorkDirection)
.set(catId).equalTo(record::getCatId)
.set(catName).equalTo(record::getCatName)
.set(picUrl).equalTo(record::getPicUrl)
.set(bookName).equalTo(record::getBookName)
.set(authorId).equalTo(record::getAuthorId)
.set(authorName).equalTo(record::getAuthorName)
.set(bookDesc).equalTo(record::getBookDesc)
.set(score).equalTo(record::getScore)
.set(bookStatus).equalTo(record::getBookStatus)
.set(visitCount).equalTo(record::getVisitCount)
.set(wordCount).equalTo(record::getWordCount)
.set(commentCount).equalTo(record::getCommentCount)
.set(lastIndexId).equalTo(record::getLastIndexId)
.set(lastIndexName).equalTo(record::getLastIndexName)
.set(lastIndexUpdateTime).equalTo(record::getLastIndexUpdateTime)
.set(isVip).equalTo(record::getIsVip)
.set(status).equalTo(record::getStatus)
.set(updateTime).equalTo(record::getUpdateTime)
.set(createTime).equalTo(record::getCreateTime)
.set(crawlSourceId).equalTo(record::getCrawlSourceId)
.set(crawlBookId).equalTo(record::getCrawlBookId)
.set(crawlLastTime).equalTo(record::getCrawlLastTime)
.set(crawlIsStop).equalTo(record::getCrawlIsStop)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
@Generated("org.mybatis.generator.api.MyBatisGenerator")
default int updateByPrimaryKeySelective(Book record) {
return UpdateDSL.updateWithMapper(this::update, book)
.set(workDirection).equalToWhenPresent(record::getWorkDirection)
.set(catId).equalToWhenPresent(record::getCatId)
.set(catName).equalToWhenPresent(record::getCatName)
.set(picUrl).equalToWhenPresent(record::getPicUrl)
.set(bookName).equalToWhenPresent(record::getBookName)
.set(authorId).equalToWhenPresent(record::getAuthorId)
.set(authorName).equalToWhenPresent(record::getAuthorName)
.set(bookDesc).equalToWhenPresent(record::getBookDesc)
.set(score).equalToWhenPresent(record::getScore)
.set(bookStatus).equalToWhenPresent(record::getBookStatus)
.set(visitCount).equalToWhenPresent(record::getVisitCount)
.set(wordCount).equalToWhenPresent(record::getWordCount)
.set(commentCount).equalToWhenPresent(record::getCommentCount)
.set(lastIndexId).equalToWhenPresent(record::getLastIndexId)
.set(lastIndexName).equalToWhenPresent(record::getLastIndexName)
.set(lastIndexUpdateTime).equalToWhenPresent(record::getLastIndexUpdateTime)
.set(isVip).equalToWhenPresent(record::getIsVip)
.set(status).equalToWhenPresent(record::getStatus)
.set(updateTime).equalToWhenPresent(record::getUpdateTime)
.set(createTime).equalToWhenPresent(record::getCreateTime)
.set(crawlSourceId).equalToWhenPresent(record::getCrawlSourceId)
.set(crawlBookId).equalToWhenPresent(record::getCrawlBookId)
.set(crawlLastTime).equalToWhenPresent(record::getCrawlLastTime)
.set(crawlIsStop).equalToWhenPresent(record::getCrawlIsStop)
.where(id, isEqualTo(record::getId))
.build()
.execute();
}
}

4
novel-book/book-service/src/main/resources/application.yml Normal file
View File

@ -0,0 +1,4 @@
spring:
profiles:
include: [common]

5
novel-book/book-service/src/main/resources/bootstrap.yml Normal file
View File

@ -0,0 +1,5 @@
spring:
application:
name: book-service
profiles:
active: dev

64
novel-book/book-service/src/main/resources/logback-boot.xml Normal file
View File

@ -0,0 +1,64 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- 彩色日志依赖的渲染类 -->
<conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
<conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
<conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
<!-- 彩色日志格式 -->
<property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}" />
<!-- %m输出的信息,%p日志级别,%t线程名,%d日期,%c类的全名,%i索引【从数字0开始递增】,,, -->
<!-- appender是configuration的子节点，是负责写日志的组件。 -->
<!-- ConsoleAppender：把日志输出到控制台 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<!--
<pattern>%d %p (%file:%line\)- %m%n</pattern>
-->
<pattern>${CONSOLE_LOG_PATTERN}</pattern>
<!-- 控制台也要使用UTF-8，不要使用GBK，否则会中文乱码 -->
<charset>UTF-8</charset>
</encoder>
</appender>
<!-- RollingFileAppender：滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->
<!-- 以下的大概意思是：1.先按日期存日志，日期变了，将前一天的日志文件名重命名为XXX%日期%索引，新的日志仍然是demo.log -->
<!-- 2.如果日期没有发生变化，但是当前日志的文件大小超过1KB时，对当前日志进行分割 重命名 -->
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<File>logs/book-service.log</File>
<!-- rollingPolicy:当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名。 -->
<!-- TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动 -->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!-- 活动文件的名字会根据fileNamePattern的值，每隔一段时间改变一次 -->
<!-- 文件名：logs/demo.2017-12-05.0.log -->
<fileNamePattern>logs/debug.%d.%i.log</fileNamePattern>
<!-- 每产生一个日志文件，该日志文件的保存期限为30天 -->
<maxHistory>30</maxHistory>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<!-- maxFileSize:这是活动文件的大小，默认值是10MB，测试时可改成1KB看效果 -->
<maxFileSize>10MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>
</rollingPolicy>
<encoder>
<!-- pattern节点，用来设置日志的输入格式 -->
<pattern>
%d %p (%file:%line\)- %m%n
</pattern>
<!-- 记录日志的编码:此处设置字符集 - -->
<charset>UTF-8</charset>
</encoder>
</appender>
<!-- 控制台输出日志级别 -->
<root level="INFO">
<appender-ref ref="STDOUT" />
<appender-ref ref="FILE" />
</root>
<!-- 指定项目中某个包，当有日志操作行为时的日志记录级别 -->
<!-- com.maijinjie.springboot 为根包，也就是只要是发生在这个根包下面的所有日志操作行为的权限都是DEBUG -->
<!-- 级别依次为【从高到低】：FATAL > ERROR > WARN > INFO > DEBUG > TRACE -->
<logger name="com.java2nb" level="DEBUG">
<appender-ref ref="STDOUT" />
<appender-ref ref="FILE" />
</logger>
</configuration>