对象关系映射（Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。如今已有很多免费和付费的ORM产品，而有些程序员更倾向于创建自己的ORM工具。
广义上，ORM指的是面向对象的对象模型和关系型数据库的数据结构之间的相互转换。 狭义上，ORM可以被认为是，基于关系型数据库的数据存储，实现一个虚拟的面向对象的数据访问接口。
2、ORM解析O：面向对象领域的Object（JavaBean对象）
R：关系数据库领域的Relational（表的结构）
M：映射Mapping（XML的配置文件）
3、ORM特点- 先让实体类与数据库表对应，再让实体类的属性与数据库表字段对应
- 不需要 *** 作数据库表，而是直接 *** 作实体类对象
优势：
提高开发效率：ORM框架自动实现Entity实体的属性与关系型数据库字段的映射。CRUD的工作则可以交给ORM来自动生成代码方式实现。隐藏了数据访问细节，“封闭”的通用数据库交互，他使得我们的通用数据库交互变得简单易行，并且完全不用考虑SQL语句。
劣势：
性能降低、复杂的查询ORM力不从心
二、Mybatis 1、环境配置 （1）修改maven仓库
新建一个项目时，最好配置自己的maven仓库位置
我自己的maven仓库放在如下的文件目录中
需要配置maven的路径以及conf下的settings文件
（2）安装lombok插件非常方便的插件，建议安装
（3）热部署配置需要配置idea
使用组合键Ctrl+A/t+Shift+/ 或者 Ctrl+A/t+a
勾选热部署工具
2、模块配置 （1）新建springboot模块 （2）引入依赖（编辑pom.xml文件）需要引入mysql、mybatis的依赖，另外我这里配置了热部署相关以及安装了lombok插件
pom文件中的内容如下所示
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.6.5
com.jtdemo
sp01_mybatis_plus_demo
0.0.1-SNAPSHOT
sp01_mybatis_plus_demo
Demo project for Spring Boot
1.8
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.2.2
org.springframework.boot
spring-boot-devtools
runtime
true
mysql
mysql-connector-java
runtime
org.projectlombok
lombok
true
org.springframework.boot
spring-boot-starter-test
test
org.springframework.boot
spring-boot-maven-plugin
org.projectlombok
lombok
将application.properties文件的后缀名改为.yml
其中需要配置Springboot数据源相关，mybatis相关，还有服务发布相关
#SpringBoot数据源配置
spring:
datasource:
#连接自己的数据库路径，用户名，密码
url: jdbc:mysql://127.0.0.1:3306/jtdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
#serverTimezone=GMT%2B(+)8 代表时区东八区
#&useUnicode=true&characterEncoding=utf8 是否使用Unicode编码 使用UTF-8字符集
#&autoReconnect=true 链接断开之后是否重连.
#&allowMultiQueries=true 是否允许批量 *** 作
username: root
password: root
#SpringBoot整合Mybatis
mybatis:
#定义别名包 作用: 以后封装POJO对象时自动进行拼接
type-aliases-package: com.jtdemo.pojo
#引入mapper配置文件
mapper-locations: classpath:/mybatis/mappers/*.xml
#开启驼峰映射
configuration:
map-underscore-to-camel-case: true
server:
port: 8090
servlet:
#项目默认发布路径/根目录
context-path: /
添加注解@MapperScan("com.jtdemo.mapper")
作用：指定要变成实现类的接口所在的包，然后包下面的所有接口在编译之后都会生成相应的实现类
如果指定的包路径不止一个，格式改为：@MapperScan({“com.jtdemo.mapper”,”com.jtdemo.mapper1”})
package com.jtdemo;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@MapperScan("com.jtdemo.mapper")
@SpringBootApplication
public class SpringbootMybatisPlusDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootMybatisPlusDemoApplication.class, args);
}
}
其中，user的属性包括id，name，age，sex
package com.jtdemo.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain=true)
public class User {
private Integer id;
private String name;
private Integer age;
private String sex;
}
package com.jtdemo.mapper;
import com.jtdemo.pojo.User;
import java.util.List;
public interface UserMapper{
//查询所有用户信息
List findAll();
} 这里也可以添加@Mapper注解，
如果主程序上没有添加@MapperScan()注解的话，这里必须添加@Mapper注解
package com.jtdemo.mapper;
import org.apache.ibatis.annotations.Mapper;
import com.jtdemo.pojo.User;
import java.util.List;
@Mapper
public interface UserMapper{
//查询所有用户信息
List findAll();
} package com.jtdemo.service;
import com.jtdemo.pojo.User;
import org.springframework.stereotype.Service;
import java.util.List;
public interface UserService{
List queryAllUsers();
} import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public List queryAllUsers() {
return userMapper.findAll();
}
} package com.jtdemo.userController;
import com.jtdemo.jsonResult.JsonResult;
import com.jtdemo.pojo.User;
import com.jtdemo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController
public class UserController {
@Autowired
private UserService userservice;
@RequestMapping("/query")
public JsonResult queryAllUsers(){
List userList=userservice.queryAllUsers();
return new JsonResult().ok().data(userList);
}
}
package com.jtdemo.jsonResult;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class JsonResult {
/**
* 成功
*/
public static final int SUCCESS = 200;
/**
* 没有登录
*/
public static final int NOT_LOGIN = 400;
/**
* 发生异常
*/
public static final int EXCEPTION = 401;
/**
* 系统错误
*/
public static final int SYS_ERROR = 402;
/**
* 参数错误
*/
public static final int PARAMS_ERROR = 403;
/**
* 不支持或已经废弃
*/
public static final int NOT_SUPPORTED = 410;
/**
* AuthCode错误
*/
public static final int INVALID_AUTHCODE = 444;
/**
* 太频繁的调用
*/
public static final int TOO_FREQUENT = 445;
/**
* 未知的错误
*/
public static final int UNKNOWN_ERROR = 499;
private int code;
private String msg;
private T data;
public static JsonResult build() {
return new JsonResult();
}
public static JsonResult build(int code) {
return new JsonResult().code(code);
}
public static JsonResult build(int code, String msg) {
return new JsonResult().code(code).msg(msg);
}
public static JsonResult build(int code, T data) {
return new JsonResult().code(code).data(data);
}
public static JsonResult build(int code, String msg, T data) {
return new JsonResult().code(code).msg(msg).data(data);
}
public JsonResult code(int code) {
this.code = code;
return this;
}
public JsonResult msg(String msg) {
this.msg = msg;
return this;
}
public JsonResult data(T data) {
this.data = data;
return this;
}
public static JsonResult ok() {
return build(SUCCESS);
}
public static JsonResult ok(String msg) {
return build(SUCCESS, msg);
}
public static JsonResult ok(T data) {
return build(SUCCESS, data);
}
public static JsonResult err() {
return build(EXCEPTION);
}
public static JsonResult err(String msg) {
return build(EXCEPTION, msg);
}
}
启动项目，访问
http://localhost:8090/query
结果展示
5、添加数据 （1）编辑mapper.xml添加insert语句
INSERT INTO user(id,name,age,sex) VALUES (null,#{name},#{age},#{sex})
//插入用户信息
int insertUser(String name,int age,String sex);int insertUser(String name,int age,String sex);@Override
public int insertUser(String name, int age, String sex) {
return userMapper.insertUser(name, age, sex);
}这里模拟要插入的用户信息
/**
* 插入用户信息
* */
@RequestMapping("/insertUser")
public JsonResult insertUser(){
//测试数据
String name="lisa";
int age=27;
String sex="女";
int successNum=userservice.insertUser(name,age,sex);
return new JsonResult().ok().data(successNum);
}输入路径
http://localhost:8090/insertUser
查看数据库信息
6、修改数据 （1）编辑mapper.xml
UPDATE user SET name=#{name} WHERE id=#{id}
//通过id修改名称
int updateUserById(int id,String name); int updateUserById(int id,String name); @Override
public int updateUserById(int id,String name) {
return userMapper.updateUserById(id,name);
} /**
* 通过id修改用户姓名
* */
@RequestMapping("/updateUserById")
public JsonResult updateUserById(){
int id=56;
String name="Jisoo";
int successNum=userservice.updateUserById(id,name);
return JsonResult.ok().data("修改名称成功！");
}输入路径：
http:localhost:8090/updateUserById
查看数据库
7、删除数据 （1）编辑mapper.xml
DELETE FROM user WHERE id=#{id}
//通过id删除数据
int deleteUser(int id);int deleteUser(int id); @Override
public int deleteUser(int id) {
return userMapper.deleteUser(id);
} /**
* 通过id删除数据
* */
@RequestMapping("/deleteUser")
public JsonResult deleteUser(){
//测试数据
int id=56;
int success=userservice.deleteUser(id);
return JsonResult.ok().data("删除数据成功");
}访问路径：
http//:localhost:8090/deleteUser
三、Mybatis-Plus 1、MP介绍MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
简单的sql语句就可以不用写了。
2、环境配置注意：此 *** 作是在mybatis项目的基础上修改得到，具体mybatis项目的配置可以参考上面第二部分的内容
（1）修改pom文件需要导入Mybatis-plus的jar包依赖，并且注掉Mybatis的依赖，否则会产生冲突
com.baomidou
mybatis-plus-boot-starter
3.4.3
将原来mybatis的注释掉，换成mybatis-plus的相关配置
差别不大，只需将mybatis修改为mybatis-plus即可
#SpringBoot整合Mybatis
#mybatis:
#定义别名包 作用: 以后封装POJO对象时自动进行拼接
#type-aliases-package: com.jtdemo.pojo
#引入mapper配置文件
#mapper-locations: classpath:/mybatis/mappers/*.xml
#开启驼峰映射
#configuration:
#map-underscore-to-camel-case: true
#SpringBoot整合Mybatis-plus
mybatis-plus:
#定义别名包 作用: 以后封装POJO对象时自动进行拼接
type-aliases-package: com.jtdemo.pojo
#引入mapper配置文件
mapper-locations: classpath:/mybatis/mappers/*.xml
#开启驼峰映射
configuration:
map-underscore-to-camel-case: true添加pojo类与数据表的映射关系
使用@TableName、@TableId、@TableField注解
- @TableName("表名")
将pojo对象与数据表关系一一对应
- @TableId(type=IdType.AUTO)
标识主键，后面括号中的内容表示主键自增
- @TableField("字段名")
标识属性与字段的一一对应关系，当属性与字段相同（包含驼峰规则），此注解可以省略
package com.jtdemo.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain=true)
@TableName("user") //使对象和表名一一对应
public class User {
@TableId(type = IdType.AUTO) //标识主键，且主键自增
@TableField("id")
private Integer id;
@TableField("name") //如果属性名与字段名一致（包含驼峰规则），此注释可以省略
private String name;
private Integer age;
private String sex;
}
需要使其继承公共接口方式，并且需要注意，继承的接口需要添加泛型
package com.jtdemo.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jtdemo.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
//继承父接口时需要添加泛型
public interface UserMapper extends BaseMapper {
//查询所有用户信息
List findAll();
}
以下均展示controller层和serviceImpl层的代码
（1）查询全部使用selectList()
/**
* 使用MP查询所有的用户信息
* http://localhost:8090/queryAllMP
* */
@RequestMapping("/queryAllMP")
public JsonResult> queryAllMP(){
List userList=userService.queryAllMP();
return new JsonResult<>().ok().data(userList);
} //MP查询所有用户信息
@Override
public List queryAllMP(){
List userList=userMapper.selectList(null);
return userList;
} 使用selectById()
/**
* 通过id查询单个用户
* restFul风格传参数
* http://localhost:8090/findById/5
* */
@RequestMapping("/findById/{id}")
public JsonResult findById(@PathVariable Integer id){
User user=userService.findById(id);
return new JsonResult<>().ok().data(user);
} //通过id查询单个用户信息
@Override
public User findById(Integer id) {
User user=userMapper.selectById(id);
return user;
}（3）通过where简单条件查询单个或多个
需要创建queryWrapper对象
查询单个时使用selectOne
查询多个时使用selectList
/**
* 通过姓名和性别查询单个用户
* http://localhost:8090/findByNameAndSex?name=唐僧&sex=男
* */
@RequestMapping("/findByNameAndSex")
public JsonResult findByNameAndSex(@RequestParam String name,@RequestParam String sex){
User user=userService.findByNameAndSex(name, sex);
return new JsonResult<>().ok().data(user);
}
/**
* 通过姓名和性别查询多个用户
* http://localhost:8090/findUsersByNameAndSex?name=貂蝉&sex=女
* */
@RequestMapping("/findUsersByNameAndSex")
public JsonResult findUsersByNameAndSex(@RequestParam String name,@RequestParam String sex){
List userList=userService.findUsersByNameAndSex(name, sex);
return new JsonResult<>().ok().data(userList);
} （4）查询大于等于小于条件
使用这些作为条件
ge 大于等于，
gt 大于，
le 小于等于，
lt 小于，
eq 等于
/**
* 查询大于等于此年龄的多个用户
* @RequestBody 从客户端提交的"请求协议体"中，完整接收协议体数据(JSON格式)，转换成商品列表
* url:http://localhost:8090/findUsersgeAge
* */
@RequestMapping("/findUsersgeAge")
public JsonResult> findUsersgeAge(@RequestBody User user){
List userList=userService.findUsersgeAge(user.getAge());
return new JsonResult<>().ok().data(userList);
} //查询 大于等于 指定年龄的多个用户 > gt < lt = eq >= ge <= le
@Override
public List findUsersgeAge(Integer age) {
QueryWrapper queryWrapper=new QueryWrapper<>();
//queryWrapper.ge("age",age); //大于等于指定年龄
queryWrapper.gt("age",age); //大于指定年龄
//queryWrapper.le("age",age); //小于等于指定年龄
//queryWrapper.lt("age",age); //小于指定年龄
//queryWrapper.eq("age",age); //等于指定年龄
return userMapper.selectList(queryWrapper);
} 使用isNull，isNotNull
/**
* 查询名字不为空的用户信息
* url: http://localhost:8090/findUsersWhereNameIsNotNull
* */
@RequestMapping("findUsersWhereNameIsNotNull")
public JsonResult> findUsersWhereNameIsNotNull(){
List userList=userService.findUsersWhereNameIsNotNull();
return new JsonResult<>().ok().data(userList);
} @Override
public List findUsersWhereNameIsNotNull() {
QueryWrapper queryWrapper=new QueryWrapper<>();
//queryWrapper.isNotNull("name"); //名字不为空
queryWrapper.isNull("name"); //名字为空
return userMapper.selectList(queryWrapper);
} （6）排序
使用orderByAsc、orderByDesc
/**
* 按照年龄升序/降序
* url: http://localhost:8090/findUsersOrderByAgeDesc
* */
@RequestMapping("findUsersOrderByAgeDesc")
public JsonResult> findUsersOrderByAgeDesc(){
List userList=userService.findUsersOrderByAgeDesc();
return new JsonResult<>().ok().data(userList);
} //按照年龄降序/升序
@Override
public List findUsersOrderByAgeDesc() {
QueryWrapper queryWrapper=new QueryWrapper<>();
//queryWrapper.orderByDesc("age"); //按照年龄降序
queryWrapper.orderByAsc("age" ); //按照年龄升序
return userMapper.selectList(queryWrapper);
} （7）模糊查询
使用like()或notLike()
/**
* 通过名字模糊查询
* like '%Li%'
* like '%Li'
* like 'L%'
* http://localhost:8090/findUsersLike/soo
* */
@RequestMapping("/findUsersLike/{name}")
public JsonResult> findUsersLike(@PathVariable String name){
List userList=userService.findUsersLike(name);
return new JsonResult<>().ok().data(userList);
} //按照名字模糊查询
@Override
public List findUsersLike(String name) {
QueryWrapper queryWrapper=new QueryWrapper();
queryWrapper.like("name", name);
//queryWrapper.notLike("name", name);
return userMapper.selectList(queryWrapper);
} （8）in & not in
如果使用queryWrapper对象时，可以使用in()或者notIn()方法
或者可以直接使用selectBatchIds()方法
/**
* 查询id为1，3，5，7，9的用户信息
* select * from user where id in (1,3,5,7,9)
* http://localhost:8090/selectUsersByIds
* */
@PostMapping("/selectUsersByIds")
public JsonResult> selectUsersByIds(@RequestBody Integer[] ids){
List userList=userService.selectUsersByIds(ids);
return new JsonResult<>().ok().data(userList);
} @Override
public List selectUsersByIds(Integer[] ids) {
//规则：如果数组需要转换为集合，需要使用包装类Integer
//将数组转为集合
List idList= Arrays.asList(ids);
// QueryWrapper queryWrapper=new QueryWrapper();
// queryWrapper.in("id", idList);
// queryWrapper.notIn("id", idList);
// return userMapper.selectList(queryWrapper);
//或者使用selectBatchIds(idList);
return userMapper.selectBatchIds(idList);
} （9）between 、notBetween
使用queryWrapper的between()或者notBetween()方法
between()方法是包含两个边界值的
notBetween()方法是不包含两个边界值的
/**
* 查询年龄段在某个区间的用户信息
* select * from user where age between 10 and 30
* between() 包含边界
* NotBetween() 不含边界
* http://localhost:8090/selectUsersBetweenAge/10/30
* */
@RequestMapping("/selectUsersBetweenAge/{prexAge}/{proAge}")
public JsonResult> selectUsersBetweenAge(@PathVariable int prexAge,@PathVariable int proAge){
List userList=userService.selectUsersBetweenAge(prexAge,proAge);
return new JsonResult<>().ok().data(userList);
} @Override
public List selectUsersBetweenAge(int prexAge, int proAge) {
QueryWrapper queryWrapper=new QueryWrapper();
//between()方法包含边界
queryWrapper.between("age", prexAge, proAge);
//notBetween()放啊不包含边界
//queryWrapper.notBetween("age", prexAge, proAge);
return userMapper.selectList(queryWrapper);
} （10）指定要查询的列(字段)
使用queryWrapper实例的select()方法，
最终的结果只有想要的字段被查询出来，其余字段为null
/**
* 查询所有用户的名字
* select name from user
* http://localhost:8090/selectUsersNames
* */
@RequestMapping("/selectUsersNames")
public JsonResult> selectUsersNames(){
List userList=userService.selectUsersNames();
return new JsonResult<>().ok().data(userList);
} @Override
public List selectUsersNames() {
QueryWrapper queryWrapper=new QueryWrapper();
queryWrapper.select("name");
return userMapper.selectList(queryWrapper);
} 直接使用insert()方法
/**
* 插入用户信息
* insert into user(id,name,age,sex) values(null,#{name},#{age},#{sex})
* http://localhost:8090/addUser
* */
@PostMapping("addUser")
public JsonResult addUser(@RequestBody User user){
userService.addUser(user);
return new JsonResult<>().ok().data("增加用户信息成功！！！");
} @Override
public int addUser(User user) {
return userMapper.insert(user);
}通过id修改使用updateById()
/**
* 根据id修改用户信息
*
* */
@PostMapping("updateUserById")
public JsonResult updateUserById(@RequestBody User user){
userService.updateUserById(user);
return new JsonResult<>().ok().data("修改用户信息成功！！！");
} @Override
public int updateUserById(User user) {
//sql生成原则，根据user实例中不为null的作为set的条件，并且以id作为where条件
return userMapper.updateById(user);
}
或者可以使用updateWrapper实例
这里表示的含义为，前端传入这个对象，并且附带需要修改的字段信息
/**
* 修改用户信息
* */
@PostMapping("updateUser")
public JsonResult updateUser(@RequestBody User user){
userService.updateUser(user);
return new JsonResult<>().ok().data("修改用户信息成功！！");
} @Override
public int updateUser(User user) {
//此对象用于封装修改的信息
User tempUser=new User();
tempUser.setName(user.getName());
tempUser.setAge(user.getAge());
UpdateWrapper updateWrapper=new UpdateWrapper<>();
//用于where条件
updateWrapper.eq("id",user.getId());
return userMapper.update(user, updateWrapper);
} （13）删除
/**
* 删除指定用户的信息
* */
@PostMapping("/deleteUser")
public JsonResult deleteUser(@RequestBody User user){
userService.deleteUser(user);
return new JsonResult<>().ok().data("删除用户成功！！");
} @Override
public int deleteUser(User user) {
QueryWrapper queryWrapper=new QueryWrapper();
queryWrapper.eq("id",user.getId());
return userMapper.delete(queryWrapper);
}欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）