Mybatis fornece algumas interfaces Mapper integradas para completar algumas operações básicas de CRUD. Essas interfaces Mapper integradas herdam a interface Mapper básica do Mybatis e definem alguns métodos comuns de adição, exclusão, modificação e consulta.
A seguir está uma lista da interface do Mapper que vem com o Mybatis e seus métodos correspondentes de adição, exclusão, modificação e consulta:
BaseMapper:
T selectByPrimaryKey(Object key)：根据主键查询数据
int deleteByPrimaryKey(Object key)：根据主键删除数据
int delete(T record)：根据实体属性作为条件进行删除，查询条件使用等号
int insert(T record)：插入一条数据
int insertSelective(T record)：插入一条数据，使用实体属性非空字段作为插入语句的字段
int updateByPrimaryKeySelective(T record)：根据主键更新一条数据，使用实体属性非空字段作为更新语句的字段
int updateByPrimaryKey(T record)：根据主键更新一条数据
ConditionMapper:
int selectCountByCondition(Object condition)：根据条件查询数据总数
List<T> selectByCondition(Object condition)：根据条件查询数据列表
int deleteByCondition(Object condition)：根据条件删除数据
int updateByCondition(T record, Object condition)：根据条件更新数据
ExemploMapper:
List<T> selectByExample(Object example)：根据Example条件查询数据
int selectCountByExample(Object example)：根据Example条件查询数据总数
int deleteByExample(Object example)：根据Example条件删除数据
int updateByExample(T record, Object example)：根据Example条件更新数据
int updateByExampleSelective(T record, Object example)：根据Example条件
Para atualizar os dados, use os campos não vazios dos atributos da entidade como os campos da instrução de atualização.
Ao usar essas interfaces Mapper integradas, você só precisa definir a classe de entidade correspondente e a classe de exemplo, e pode chamar diretamente seus correspondentes métodos para concluir as operações de adição, exclusão, modificação e consulta.
Deve-se notar que os parâmetros e tipos de valores de retorno desses métodos são tipos genéricos, que precisam ser especificados de acordo com o tipo específico de classe de entidade. Além disso, os nomes dos métodos e dos parâmetros na interface interna do Mapper possuem certas regras, que precisam ser nomeadas de acordo com as regras.No uso real, você precisa verificar cuidadosamente a documentação.
1. A seguir está um exemplo de código que explica em detalhes o BaseMapper em Mybatis.
Primeiro, precisamos definir uma classe de entidade User, que é usada para mapear a tabela do usuário no banco de dados, e definir os atributos correspondentes, métodos de construção e métodos get e set nela:
public class User {
private Long id;
private String name;
private Integer age;
private Integer gender;
private Date createTime;
private Date updateTime;
public User() {
}
public User(Long id, String name, Integer age, Integer gender, Date createTime, Date updateTime) {
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
this.createTime = createTime;
this.updateTime = updateTime;
}
// 省略get、set方法
}
Em seguida, precisamos definir uma interface Mapper UserMapper correspondente, herdada da interface BaseMapper do Mybatis, para operar a tabela de banco de dados mapeada pela classe de entidade User:
public interface UserMapper extends BaseMapper<User> {
}
Na interface UserMapper, herdamos a interface BaseMapper de Mybatis e especificamos o tipo genérico como User, para que os métodos definidos em BaseMapper possam ser usados para completar a operação da tabela de banco de dados mapeada para a classe de entidade User.
Finalmente, podemos testar os métodos definidos no BaseMapper com o seguinte código:
public class MybatisDemo {
public static void main(String[] args) {
// 通过SqlSessionFactoryBuilder构建SqlSessionFactory
InputStream inputStream = MybatisDemo.class.getResourceAsStream("/mybatis-config.xml");
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory sessionFactory = builder.build(inputStream);
// 通过SqlSessionFactory获取session对象
try (SqlSession session = sessionFactory.openSession()) {
// 获取UserMapper接口的实现类对象
UserMapper userMapper = session.getMapper(UserMapper.class);
// 新增用户
User user = new User();
user.setName("Tom");
user.setAge(20);
user.setGender(1);
user.setCreateTime(new Date());
user.setUpdateTime(new Date());
userMapper.insertSelective(user);
// 根据ID查询用户
User result = userMapper.selectByPrimaryKey(user.getId());
System.out.println(result);
// 修改用户
result.setName("Jerry");
result.setGender(2);
result.setUpdateTime(new Date());
userMapper.updateByPrimaryKey(result);
// 查询所有用户
List<User> userList = userMapper.selectAll();
System.out.println(userList);
// 删除用户
userMapper.deleteByPrimaryKey(result.getId());
}
}
}
No código acima, primeiro obtivemos o objeto da classe de implementação da interface UserMapper e, em seguida, usamos os métodos definidos no BaseMapper para concluir operações como adicionar, excluir, modificar e verificar. Por exemplo, use o método insertSelective para inserir um dado, use o método selectByPrimaryKey para consultar dados com base no ID, use o método updateByPrimaryKey para atualizar dados com base na chave primária, use o método selectAll para consultar todos os dados e use o método deleteByPrimaryKey para excluir dados com base na chave primária, etc.
Resumindo, ao herdar a interface BaseMapper, podemos usar facilmente os métodos comuns de adição, exclusão, modificação e consulta que acompanham o Mybatis para melhorar a eficiência do desenvolvimento.
2. A seguir está um exemplo de código que explica em detalhes o ConditionMapper no Mybatis.
Primeiro, precisamos definir uma classe de entidade User, que é usada para mapear a tabela do usuário no banco de dados, e definir os atributos correspondentes, métodos de construção e métodos get e set nela:
public class User {
private Long id;
private String name;
private Integer age;
private Integer gender;
private Date createTime;
private Date updateTime;
public User() {
}
public User(Long id, String name, Integer age, Integer gender, Date createTime, Date updateTime) {
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
this.createTime = createTime;
this.updateTime = updateTime;
}
// 省略get、set方法
}
Em seguida, precisamos definir uma interface Mapper UserMapper correspondente, herdada da interface ConditionMapper do Mybatis, para operar a tabela de banco de dados mapeada pela classe de entidade User:
public interface UserMapper extends ConditionMapper<User> {
}
Na interface UserMapper, herdamos a interface ConditionMapper de Mybatis e especificamos o tipo genérico como User, para que o método definido em ConditionMapper possa ser usado para completar a operação de consulta condicional da tabela de banco de dados mapeada para a classe de entidade User.
Finalmente, podemos testar os métodos definidos no ConditionMapper com o seguinte código:
public class MybatisDemo {
public static void main(String[] args) {
// 通过SqlSessionFactoryBuilder构建SqlSessionFactory
InputStream inputStream = MybatisDemo.class.getResourceAsStream("/mybatis-config.xml");
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory sessionFactory = builder.build(inputStream);
// 通过SqlSessionFactory获取session对象
try (SqlSession session = sessionFactory.openSession()) {
// 获取UserMapper接口的实现类对象
UserMapper userMapper = session.getMapper(UserMapper.class);
// 创建查询参数对象
Query<User> query = new Query<>(User.class);
query.eq("id", 1L); // ID等于1
query.eq("name", "Tom"); // 名称等于Tom
query.result().include("name", "age"); // 只查询名称和年龄两列
// 根据条件查询用户
List<User> userList = userMapper.selectList(query);
System.out.println(userList);
}
}
}
No código acima, primeiro obtemos o objeto da classe de implementação da interface UserMapper e, em seguida, usamos o método definido em ConditionMapper para concluir a operação de consulta condicional. Por exemplo, use o método eq para definir as condições de consulta, use o método result para definir as colunas de resultados da consulta e, finalmente, use o método selectList para executar a operação de consulta.
3. A seguir está um exemplo de código que explica em detalhes o ExampleMapper em Mybatis.
Primeiro, precisamos definir uma classe de entidade User, que é usada para mapear a tabela do usuário no banco de dados, e definir os atributos correspondentes, métodos de construção e métodos get e set nela:
public class User {
private Long id;
private String name;
private Integer age;
private Integer gender;
private Date createTime;
private Date updateTime;
public User() {
}
public User(Long id, String name, Integer age, Integer gender, Date createTime, Date updateTime) {
this.id = id;
this.name = name;
this.age = age;
this.gender = gender;
this.createTime = createTime;
this.updateTime = updateTime;
}
// 省略get、set方法
}
Em seguida, precisamos definir uma interface Mapper UserMapper correspondente, herdada da interface ExampleMapper do Mybatis, para operar a tabela de banco de dados mapeada pela classe de entidade User:
public interface UserMapper extends ExampleMapper<User> {
}
Na interface UserMapper, herdamos a interface ExampleMapper de Mybatis e especificamos o tipo genérico como User, para que o método definido em ExampleMapper possa ser usado para completar a operação de consulta de exemplo na tabela de banco de dados mapeada para a classe de entidade User.
Finalmente, podemos testar os métodos definidos em ExampleMapper com o seguinte código:
public class MybatisDemo {
public static void main(String[] args) {
// 通过SqlSessionFactoryBuilder构建SqlSessionFactory
InputStream inputStream = MybatisDemo.class.getResourceAsStream("/mybatis-config.xml");
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
SqlSessionFactory sessionFactory = builder.build(inputStream);
// 通过SqlSessionFactory获取session对象
try (SqlSession session = sessionFactory.openSession()) {
// 获取UserMapper接口的实现类对象
UserMapper userMapper = session.getMapper(UserMapper.class);
// 创建Example参数对象
Example<User> example = Example.builder(User.class)
.where(ExampleCondition.create()
.andEqualTo(User::getId, 1L)
.andEqualTo(User::getName, "Tom"))
.select(User::getName, User::getAge)
.build();
// 根据Example查询用户
List<User> userList = userMapper.selectByExample(example);
System.out.println(userList);
}
}
}
No código acima, primeiro obtemos o objeto da classe de implementação da interface UserMapper e, em seguida, usamos o método definido em ExampleMapper para concluir a operação de consulta de exemplo. Por exemplo, use o método where para definir as condições de consulta, use o método select para definir as colunas de resultados da consulta e, finalmente, use o método selectByExample para executar a operação de consulta.