后端笔记
Mybatis框架-noSpring
连接mysql数据库
//Mybatis
String resourse = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resourse);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
userMapper userMapper = sqlSession.getMapper(userMapper.class);
List<User> users = userMapper.selectAll();
System.out.println(users);
sqlSession.close();
//引入jar包后的原生
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useSSL=false&useSSL=false&serverTimezone=UTC","root","sql666");
String sql = "insert into sqltest (name,age,school) value ('sdf',23,'45')";
Statement stmt = conn.createStatement();
System.out.println(stmt.executeUpdate(sql));
stmt.close();
conn.close();
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC"/>
<property name="username" value="root"/>
<property name="password" value="sql666"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/test/userMapper.xml"/>
</mappers>
</configuration>
pom.xml配置文件
<dependencies>
<!-- servlet依赖-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
<!-- mybits依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.5</version>
</dependency>
<!--mysql依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.16</version>
</dependency>
</dependencies>
<!--json解析包-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.54</version>
</dependency>
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<path>/</path>
<port>80</port>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>14</source>
<target>14</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>13</source>
<target>13</target>
</configuration>
</plugin>
</plugins>
</build>
-Mapper.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">
<!--namespace 指向class映射文件(mapper接口)的位置-->
<mapper namespace="com.test.userMapper">
<select id="selectAll" resultType="com.test.User">
select * from sqltest;
</select>
<select id="insertData" resultType="com.test.User">
insert into sqltest (name,age) value ( #{name},#{age});
</select>
</mapper>
Tomcat插件
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<configuration>
<path>/</path>
<port>80</port>
</configuration>
</plugin>
servlet依赖
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>javax.servlet.jsp-api</artifactId>
<version>2.3.3</version>
<scope>provided</scope>
</dependency>
SQL语言
id 顺序排列
ALTER TABLE BN DROP COLUMN id;
ALTER TABLE BN ADD id int NOT NULL PRIMARY KEY AUTO_INCREMENT FIRST;
show databases;
drop database if exists hardware_sys;
#创建数据库并指定字符集
create database if not exists question_bank default character set utf8 collate utf8_general_ci;
use hardware_sys;
drop table if exists hardware_sys.user_data;
drop table if exists hardware_sys.hardware_data;
create table if not exists user_data
(
id int primary key auto_increment,
name varchar(20) not null ,
password varchar(50) not null ,
status smallint,
mana smallint
#默认字符集
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
select *
from hardware_data;
#数据库字符
SHOW VARIABLES LIKE 'char%';
set character_set_results =utf8;
mysql区分大小写
创建时设置：
CREATE TABLE T(
A VARCHAR(10) BINARY
);
使用alter修改：
ALTER TABLE `tablename` MODIFY COLUMN `cloname` VARCHAR(45) BINARY;
mysql table editor中直接勾选BINARY项。
项目结构
mapper文件
存放Mybatis的映射类，定义执行SQL语句的函数，传递对应的值
pojo文件
存放定义好的简单java对象
service文件
存放调用工具类具体执行SQL语句的接口，imp则对接口进行实现，在servlet中怎直接创建对象调用方法。
utils文件
作为工具类，创建SqlSessitionFactory 工厂对象，因为此对象可以被复用，用static定义。
web.servlet文件
服务端文件，对Http请求进行响应，对应的实现与数据库的连接，数据交互。
resource文件
包含数据库的映射文件，以及mybatis的配置文件
web-app
存放前端的页面文件
环境搭建
MYSQL安装
下载地址：
https://downloads.mysql.com/archives/installer/
所用版本为 （5.7.35）
下载，解压，配置环境变量
或许要cmd输入’services.msc’，启动服务
验证环境变量是否配置好，按下“window+R”键弹出运行框，输入“cmd”进入window命令行，输入“mysql -u root -p”按下回车，再输入密码，按下回车。有welcome则成功。
详细安装教程：
https://blog.csdn.net/weixin_50498482/article/details/124315351
登录参数
mysql -uxxx -pxxx -h127.0.0.1 -p 3306
Navicat安装
解压安装即可
点击连接，输入主机端口，用户名，端口来连接到数据库
Maven安装
管理和构建java项目的工具
提供标准项目结构，标准化构建流程，依赖管理机制。
下载解压安装
在maven->conf->settings.xml中配置阿里云的镜像，在mirrors节点下面添加子节点
<mirror>
<id>nexus-aliyun</id>
<mirrorOf>central</mirrorOf>
<name>Nexus aliyun</name>
<url>http://maven.aliyun.com/nexus/content/groups/public</url>
</mirror>
浏览仓库内容
https://developer.aliyun.com/mvn/guide
常用命令
1.compile 编译 2. clean 3. test 4. package 5. install
IDEA配置maven
settings -> 搜索maven -> 配置home path -> 配置文件settings file -> 选择对应文件
导入maven项目
选择右侧maven面板 -> 点击+ -> 选择porn.xml文件
没有面板则 view -> appearance -> tool windows bar
Mybatis安装
持久层框架，简化JDBC开发
持久层 -> 将数据保存到数据库
配置文档
https://mybatis.net.cn/getting-started.html
maven导入依赖 -> 配置文件mybatis.xml -> 映射文件mapper
IDEA连接数据库
右侧菜单 -> datasource -> mysql -> 填写数据库信息
Mapper代理
通过 SqlSession 的 getMapper 获取Mapper接口
Tomcat安装
下载安装
https://tomcat.apache.org/download-80.cgi
解决控制台乱码
conf -> logging.properties -> consoleHa… encodeing = GBK
server.xml 中可以更改端口
connector port = “80”
窗口一闪而过则是，java 环境配置错误
创建mavenWeb项目
-> 补全目录即可
IDEA中使用Tomcat
sevlet配置
1.创建web项目，导入依赖
2.定义类实现接口
3.使用@Webservlet(“/path”)注解，配置访问路径
4.浏览器访问
读写excel表格
导入依赖
<!-- EasyExcel -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
<version>2.2.6</version>
</dependency>
<!--通过注解生成setter and getter-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version>
</dependency>
创建对象
//lombok能创建setter getter 方法
@Setter
@Getter
@ToString
public class question {
//忽视对象中的此成员
@ExcelIgnore
private int id;
//excel表格读取和储存的表头
@ExcelProperty(value = "题目")
private String topic;
@ExcelProperty(value = "选项1")
private String option_o;
}
//将数据写入list集合中
List<question> ques = new ArrayList<>();
for (int i=0;i < 10; i++) {
question qu = new question();
qu.setId(i);
qu.setTopic(i);
qu.setOption_o(i);
ques.add(qu);
}
//写入excel表格
EasyExcel.write("XXX/123.xlsx", //文件路径
question.class) //对象class
.sheet("题目") //表名
.doWrite(ques); //写入集合
//读取excel表格
String filePath = "XXX/123.xlsx";
List<question> list = EasyExcel
.read(filePath)
.head(question.class) //根据class获取表头
.sheet()
.doReadSync();
Spring
使用xml配置
ApplicationContext.xml
<bean id = "userDao" class="com.colorful.dao.userDaoImp">
<!-- 注入普通数据类型-->
<property name="string" value="123"/>
<!-- 注入集合数据类型-->
<property name="list">
<list>
<value>345</value>
<value>568</value>
</list>
</property>
<property name="map">
<map>
<entry key="name" value="123"/>
<entry key="password" value="123"/>
</map>
</property>
</bean>
<bean id="userDaoService" class="com.colorful.service.userDaoService">
<!-- 注入引用数据类型(userDao对象)-->
<property name="userDao" ref="userDao"/>
</bean>
<!-- 引入其他配置文件（分模块开发）-->
<!-- <import resource="ApplicationContext.xml"/>-->
对应类中
//需要有setter
@Setter
public class userDaoImp implements userDao {
private String string;
private List<String> list;
private Map<String, String> map;
}
//测试
ApplicationContext ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
userDaoService service = (userDaoService) ac.getBean("userDaoService");
service.call();
导入外部.properties配置文件
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 导入外部配置文件-->
<context:property-placeholder location="classpath:test.properties"/>
<property name="string" value="${value}"/>
注解配置
@Setter
@ToString
//组件注解，配置id标识
@Component("userDaoService")
public class userDaoService {
//注入引用类型(ref)
//Resource("userDaoImp")
@Autowired
@Qualifier("userDaoImp")
private userDao userDao;
public void call() {
System.out.println(userDao);
userDao.call();
}
}
在xml中加入组件扫描
<!-- 组件扫描-->
<context:component-scan base-package="com.colorful"/>
config配置类
com -> config -> springConfiguration.class
//相当于头部文件
@Configurable
//组件扫描
@ComponentScan("com.colorful")
//properties配置文件
@PropertySource("test.properties")
//加载其他配置
@Import({class,class})
public class springConfiguration {
//第三方
/*@Bean("dataSource")
public data dateSource() {
xxx = new xxx;
return xxx
}*/
}
测试
ApplicationContext ac = new AnnotationConfigApplicationContext(springConfiguration.class);
userDaoService service = ac.getBean(userDaoService.class);
service.call();
spirngMVC
导入坐标
springMVC配置类
//springmvc配置类，本质上还是一个spring配置类
@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig {
}
controller -> usercontroller 请求处理
//定义表现层控制器bean
@Controller
//设置操作返回结果为指定json数据（本质上是一个字符串信息）
@ResponseBody
public class userController {
@RequestMapping("/user/save")
public String save() {
System.out.println("save id running");
return "springmvc";
}
}
在启动服务器时加载mvc，设置请求拦截的路径
//web容器配置类
public class ServletConfig extends AbstractDispatcherServletInitializer {
//加载springmvc配置类，产生springmvc容器（本质还是spring容器）
protected WebApplicationContext createServletApplicationContext() {
//初始化WebApplicationContext对象
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
//加载指定配置类
ctx.register(SpringMvcConfig.class);
return ctx;
}
//设置由springmvc控制器处理的请求映射路径
protected String[] getServletMappings() {
return new String[]{"/"};
}
//加载spring配置类
protected WebApplicationContext createRootApplicationContext() {
return null;
}
}
controller加载
避免Spring错误的加载到SpringMVC的bean
方式一 (springConfig)
@Configuration
@ComponentScan(value = "com.itheima",
excludeFilters = @ComponentScan.Filter(
type = FilterType.ANNOTATION,
classes = Controller.class
)
)
public class SpringConfig {
}
方式二(设置精确加载)
@ComponentScan({xxx,xxx})
servletConfig加载springConfig
public class ServletConfig extends AbstractDispatcherServletInitializer {
//加载springMvcConfig
protected WebApplicationContext createServletApplicationContext() {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
ctx.register(SpringMvcConfig.class);
return ctx;
}
//加载springConfig
protected WebApplicationContext createRootApplicationContext() {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
ctx.register(SpringConfig.class);
return ctx;
}
//配置拦截与访问路径
protected String[] getServletMappings() {
return new String[]{"/"};
}
}
可以进行简化
public class ServletConfig extends AbstractAnnotationConfigDispatcherServletInitializer{
//加载springMvcConfig
protected Class<?>[] getServletConfigClasses() {
return new Class[]{SpringMvcConfig.class}
};
//配置拦截与访问路径
protected String[] getServletMappings() {
return new String[]{"/"};
}
//加载springConfig
protected Class<?>[] getRootConfigClasses() {
return new Class[]{SpringConfig.class};
}
}
参数传递
普通参数
//http://xxx/user/call?aa=bb
@RequestMapping("/call")
public String call(String aa) {
System.out.println(aa);
return aa;
}
GET请求中文乱码问题解决：
在pom.xml添加tomcat7插件处配置UTF-8字符集，解决GET请求中文乱码问题。
<build>
<plugins>
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.1</version>
<configuration>
<port>80</port><!--tomcat端口号-->
<path>/</path> <!--虚拟目录-->
<uriEncoding>UTF-8</uriEncoding><!--访问路径编解码字符集-->
</configuration>
</plugin>
</plugins>
</build>
POST请求普通参数
请求参数与形参名相同即可
@RequestMapping("/commonParam")
@ResponseBody
public String commonParam(String name ,int age){
System.out.println("普通参数传递 name ==> "+name);
System.out.println("普通参数传递 age ==> "+age);
return "post";
}
不相同时可用@RequestParam(“aa”)
public String commonParam(@RequestParam("aa") String name ,int age)
POST请求乱码
在运行加载SpringMVC配置的配置类中指定字符过滤器。
//乱码处理
@Override
protected Filter[] getServletFilters() {
CharacterEncodingFilter filter = new CharacterEncodingFilter();
filter.setEncoding("UTF-8");
return new Filter[]{filter};
}
POJO参数
请求参数与形参对象中的属性对应即可完成参数传递
@RequestMapping("/pojoParam")
@ResponseBody
public String pojoParam(User user){
System.out.println("pojo参数传递 user ==> "+user);
return "pojo param";
}
嵌套POJO类型参数
- POJO对象中包含POJO对象
public class User {
private String name;
private int age;
private Address address;
//同学们自己添加getter/setter/toString()方法
}
public class Address {
private String province;
private String city;
private Address address;
}
嵌套POJO参数：请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJO属性参数
数组类型参数
- 数组参数：请求参数名与形参对象属性名相同且请求参数为多个，定义数组类型即可接收参数
//数组参数：同名请求参数可以直接映射到对应名称的形参数组对象中
@RequestMapping("/arrayParam")
@ResponseBody
public String arrayParam(String[] likes){
System.out.println("数组参数传递 likes ==> "+ Arrays.toString(likes));
return "array param'";
}
集合类型参数
//集合参数：同名请求参数可以使用@RequestParam注解映射到对应名称的集合对象中作为数据
@RequestMapping("/listParam")
@ResponseBody
public String listParam(@RequestParam List<String> likes){
System.out.println("集合参数传递 likes ==> "+ likes);
return "{'module':'list param'}";
}
JSON参数
添加坐标
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.9.0</version>
</dependency>
开启自动转换json数据的支持
@Configuration
@ComponentScan("com.itheima.controller")
//开启json数据类型自动转换
@EnableWebMvc
public class SpringMvcConfig {
}
在Controller中编写方法接收json参数
集合
//集合参数：json格式(数组)
//1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
//2.使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> likes){
System.out.println("list common(json)参数传递 list ==> "+likes);
return "{'module':'list common for json param'}";
}
pojo
//POJO参数：json格式(对象)
//1.开启json数据格式的自动转换，在配置类中开启@EnableWebMvc
//2.使用@RequestBody注解将外部传递的json数据映射到形参的实体类对象中，要求属性名称一一对应
@RequestMapping("/pojoParamForJson")
@ResponseBody
public String pojoParamForJson(@RequestBody User user){
System.out.println("pojo(json)参数传递 user ==> "+user);
return "{'module':'pojo for json param'}";
}
@RequestBody注解介绍
名称：@RequestBody
类型：==形参注解==
位置：SpringMVC控制器方法形参定义前面
作用：将请求中请求体所包含的数据传递给请求参数，此注解一个处理器方法只能使用一次
@RequestParam用于接收url地址传参，表单传参【application/x-www-form-urlencoded】
@RequestBody用于接收json数据【application/json】
日期参数
//日期参数 http://localhost:80/dataParam?date=2088/08/08&date1=2088-08-18&date2=2088/08/28 8:08:08
//使用@DateTimeFormat注解设置日期类型数据格式，默认格式yyyy/MM/dd
@RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
@DateTimeFormat(pattern="yyyy-MM-dd") Date date1,
@DateTimeFormat(pattern="yyyy/MM/dd HH:mm:ss") Date date2){
System.out.println("参数传递 date ==> "+date);
System.out.println("参数传递 date1(yyyy-MM-dd) ==> "+date1);
System.out.println("参数传递 date2(yyyy/MM/dd HH:mm:ss) ==> "+date2);
return "data param";
}
响应
响应页面
public String
return "index.jsp";
响应json数据
//需要在SpringMvcConfig配置类中 @EnableWebMvc注解
//pojo对象
new pojo();
setxxx();
//pojo对象会自动转成JSON对象
return pojo;
//集合pojo对象
list.add(pojo1);
list.add(pojo2);
//pojo集合会自动转为JSON集合
return list;
REST风格
REST风格描述形式
http://localhost/users/1
http://localhost/users
以加s形式描述
优点：
- 隐藏资源的访问行为，无法通过地址得知对资源是何种操作
- 书写简化
根据rest风格对资源进行访问称为restful
//设置当前请求方法为POST，表示REST风格中的添加操作
@RequestMapping(value = "/users",method = RequestMethod.POST)
@ResponseBody
public String save(){
System.out.println("user save...");
return "{'module':'user save'}";
}
//设置当前请求方法为DELETE，表示REST风格中的删除操作
//@PathVariable注解用于设置路径变量（路径参数），要求路径上设置对应的占位符，并且占位符名称与方法形参名称相同
@RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id){
System.out.println("user delete..." + id);
return "{'module':'user delete'}";
}
//设置当前请求方法为PUT，表示REST风格中的修改操作
//设置当前请求方法为GET，表示REST风格中的查询操作
@RequestParam用于接收url地址传参或表单传参
@RequestBody用于接收json数据
@PathVariable用于接收路径参数，使用{参数名称}描述路径参数
@PathVariable 形参与参数名要对应，不对应则写@PathVariable("aa")
简化
@RequestMapping(value="/{xxx}",method=RequestMethod.POST)
-> @POSTMapping("/{xxx}")
设置对静态资源放行
@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
//设置静态资源访问过滤，当前类需要设置为配置类，并被扫描加载
@Override
protected void addResourceHandlers(ResourceHandlerRegistry registry) {
//当访问/pages/????时候，从/pages目录下查找内
registry.addResourceHandler("/**").addResourceLocations("/");
registry.addResourceHandler("/pages/**")
.addResourceLocations("/pages/");
registry.addResourceHandler("/js/**")
.addResourceLocations("/js/");
registry.addResourceHandler("/css/**")
.addResourceLocations("/css/");
registry.addResourceHandler("/font/**")
.addResourceLocations("/font/");
}
}
Spring整合Mybatis
jdbc.properties
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/hardware_sys?useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=sql666
SpringConfig中引入properties文件
@PropertySource("classpath:jdbc.properties")
JdbcConfig
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
//数据库连接池
@Bean
public DataSource dateSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(driver);
dataSource.setUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
//Spring事务管理需要平台事务管理器对象
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
DataSourceTransactionManager ds = new DataSourceTransactionManager();
ds.setDataSource(dataSource);
return ds;
}
}
MybatisConfig
public class MyBatisConfig {
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) throws Exception {
SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
factoryBean.setDataSource(dataSource);
factoryBean.setTypeAliasesPackage("com.colorful.domain");
//开启驼峰命名转换
org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
configuration.setMapUnderscoreToCamelCase(true);
factoryBean.setConfiguration(configuration);
return factoryBean;
}
//映射文件扫描
@Bean
public MapperScannerConfigurer mapperScannerConfigurer() {
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.colorful.dao");
return msc;
}
}
SpringConfig中引入mybatis与jdbcconfig文件
@Import({JdbcConfig.class, MyBatisConfig.class})
DAO层
public interface UserDao {
@Select("select * from user_data where name = #{name} and password = #{password}")
public User userVerify(@Param("name") String name, @Param("password") String password);
}
DOMAIN
@Getter
@Setter
@ToString
public class User {
private int id;
private String name;
private String password;
private boolean status;
private boolean mana;
}
service配置dao
@Autowired
private HardwareDao hardwareDao;
表现层数据封装
Result类定义响应结果
@Getter
@Setter
@ToString
public class Result {
private Integer code;
private Object data;
private String message;
public Result(Integer code, Object data) {
this.code = code;
this.data = data;
}
public Result(Integer code, Object data, String message) {
this.code = code;
this.data = data;
this.message = message;
}
}
响应码
public class Code {
public static final Integer POST_OK = 10011;
public static final Integer DEL_OK = 10021;
public static final Integer PUT_OK = 10031;
public static final Integer GET_OK = 10041;
public static final Integer POST_ERR = 10010;
public static final Integer DEL_ERR = 10020;
public static final Integer PUT_ERR = 10030;
public static final Integer GET_ERR = 10040;
}
表现层数据封装返回Result对象
@PostMapping
public Result addHardrware(@RequestBody Hardware hardware) {
boolean flag = service.addHardware(hardware.getName(), hardware.getHardwareId(), hardware.getHardwarePort());
return new Result(flag ? Code.POST_OK: Code.POST_ERR,flag,"添加");
}