创建项目命名SSM
创建模块命名为MyBatis_HelloWorld
打包方式设置为jar
<packaging>jar</packaging>引入依赖
<dependencies>
<!-- Mybatis核心 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<!-- junit测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- MySQL驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.3</version>
<!--因为我的maver库李MySQL版本为5.1.3所以我的版本号为5.1.3 根据自身版本修改-->
</dependency>
</dependencies>
打开sqlyog创建数据库ssm并创建表t_user
CREATE TABLE `t_user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(20) DEFAULT NULL,
`password` varchar(20) DEFAULT NULL,
`age` int(11) DEFAULT NULL,
`gender` char(1) DEFAULT NULL,
`emall` varchar(50) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
private Integer id;
private String username;
private String password;
private Integer age;
private String gender;
private String email;
public User() {
}
public User(Integer id, String username, String password, Integer age, String gender, String email) {
this.id = id;
this.username = username;
this.password = password;
this.age = age;
this.gender = gender;
this.email = email;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}<?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：设置默认使用的环境的id
-->
<environments default="development">
<!--
environment：设置具体的连接数据库的环境信息
属性：
id：设置环境的唯一标识，可通过environments标签中的default设置某一个环境的id，表示默认使用的环境
-->
<environment id="development">
<!--
transactionManager：设置事务管理方式
属性：
type：设置事务管理方式，type="JDBC|MANAGED"
type="JDBC"：设置当前环境的事务管理都必须手动处理
type="MANAGED"：设置事务被管理，例如spring中的AOP
-->
<transactionManager type="JDBC"/>
<!--
dataSource：设置数据源
属性：
type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建
type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
type="JNDI"：调用上下文中的数据源
-->
<dataSource type="POOLED">
<!--设置驱动类的全类名-->
<property name="driver" value="com.mysql.seven.jdbc.Driver"/>
<!--设置连接数据库的连接地址-->
<property name="url" value="jdbc:mysql://localhost:13306"/>
<!--设置连接数据库的用户名-->
<property name="username" value="root"/>
<!--设置连接数据库的密码-->
<property name="password" value="XXXXXXX"/>
</dataSource>
</environment>
</environments>
<!--引入映射文件-->
<mappers>
<mapper resource="UserMapper.xml"/>
<!--
以包为单位，将包下所有的映射文件引入核心配置文件
注意：
1. 此方式必须保证mapper接口和mapper映射文件必须在相同的包下
2. mapper接口要和mapper映射文件的名字一致
-->
</mappers>
</configuration>
MyBatis中的mapper接口相当于以前的dao。但是区别在于，mapper仅仅是接口，我们不需要提供实现类。
public interface UserMapper {
int insertUser();
}
在resources目录下创建mappers目录在mappers目录下创建UserMapper.xml配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.seven.mybatis.mapper.UserMapper">
<!-- mapper接口要和映射文件保持两个一致
1.mapper接口的全类名和映射文件的namespace一致
2.mapper接口的方法名要和映射文件的sql的id保持一致
-->
<!-- int insertUser();-->
<insert id="insertUser">
insert into t_user values (null,'admin','123456',23,'男','2289938711@qq.com')
</insert>
</mapper>如果报错的话就是没有把mybatis添加到库里面
package com.seven.mybatis;
import com.seven.mybatis.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
/**
* @name hk
* @time 2022-08-31-17:59
*/
public class MyBatisTest {
@Test
public void test() throws IOException {
//获取核心配置文件的输入流
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
//获取SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//获取SqlSessionFactory对象
SqlSessionFactory build = sqlSessionFactoryBuilder.build(is);
//获取SQL的会话对象SqlSession,是MyBatis提供的操作数据库的对象
SqlSession sqlSession = build.openSession();
//获取UserMapper代理实现类对象
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.insertUser();
System.out.println(i);
sqlSession.close();
}
}
查看sqlyog是否添加成功
2022/8/31 20:11:00
//获取核心配置文件的输入流
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
//获取SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//获取SqlSessionFactory对象
SqlSessionFactory build = sqlSessionFactoryBuilder.build(is);
//获取SQL的会话对象SqlSession()不会自动提交事务,是MyBatis提供的操作数据库的对象
//SqlSession sqlSession = build.openSession();
//获取SQL的会话对象SqlSession(true)会自动提交事务,是MyBatis提供的操作数据库的对象
SqlSession sqlSession = build.openSession(true);
//获取UserMapper代理实现类对象
//UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//提供sql以及唯一标识找到sql并执行,唯一标识是namespace.sqlId
int i = sqlSession.insert("com.seven.mybatis.mapper.UserMapper.insertUser");
//int i = mapper.insertUser();
System.out.println(i);
//提交事务
//sqlSession.commit();
sqlSession.close(); <!-- log4j日志 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies><?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
<param name="Encoding" value="UTF-8" />
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
</layout>
</appender>
<logger name="java.sql">
<level value="debug" />
</logger>
<logger name="org.apache.ibatis">
<level value="info" />
</logger>
<root>
<level value="debug" />
<appender-ref ref="STDOUT" />
</root>
</log4j:configuration>package com.seven.mybatis.utils;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.IOException;
import java.io.InputStream;
/**
* @name hk
* @time 2022-09-01-15:59
*/
public class SqlSessionUtil {
public static SqlSession getSqlSession(){
SqlSession sqlSession =null;
try {
//获取核心配置文件的输入流
InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
//获取SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//获取SqlSessionFactory对象
SqlSessionFactory build = builder.build(is);
//获取SqlSession对象
sqlSession = build.openSession(true);
} catch (IOException e) {
e.printStackTrace();
}
return sqlSession;
}
}
<!-- void upDateUser();-->
<update id="upDateUser">
update t_user set gender = '女' where id =2
</update> public void upData(){
SqlSession sqlSession = SqlSessionUtil.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.upDateUser();
sqlSession.close();
}
<!-- void deleteUser();-->
<delete id="deleteUser">
delete from t_user where id =3
</delete>public void delete(){
SqlSession session = SqlSessionUtil.getSqlSession();
UserMapper mapper = session.getMapper(UserMapper.class);
mapper.deleteUser();
session.close();
}
查询单行信息
<!-- User getUserById();-->
<!--
resultType:设置结果类型，即查询到的数据要转换成的Java类型
resultMap：自定义映射，处理多对一或一对多的映射关系
-->
<select id="getUserById" resultType="com.seven.mybatis.pojo.User">
select * from t_user where id= 1
</select>public void getUserById(){
SqlSession session = SqlSessionUtil.getSqlSession();
UserMapper mapper = session.getMapper(UserMapper.class);
User userById = mapper.getUserById();
System.out.println(userById);
session.close();
}
查询全部信息
<!-- List<User> getAllUser(); -->
<select id="getAllUser" resultType="com.seven.mybatis.pojo.User">
select * from t_user
</select> public void getAllUser(){
SqlSession session = SqlSessionUtil.getSqlSession();
UserMapper mapper = session.getMapper(UserMapper.class);
List<User> allUser = mapper.getAllUser();
allUser.forEach(System.out::println);
session.close();
}
typeAliases标签
<typeAliases>
<!--
typeAlias：设置某个具体的类型的别名
属性：
type：需要设置别名的类型的全类名
alias：设置此类型的别名，且别名不区分大小写。若不设置此属性，该类型拥有默认的别名，即类名
-->
<!--<typeAlias type="com.seven.mybatis.bean.User"></typeAlias>-->
<!--<typeAlias type="com.seven.mybatis.bean.User" alias="user">
</typeAlias>-->
<!--以包为单位，设置改包下所有的类型都拥有默认的别名，即类名且不区分大小写-->
<package name="com.seven.mybatis.bean"/>
</typeAliases>environments标签
<environments default="development">
<!--
environment：设置具体的连接数据库的环境信息
属性：
id：设置环境的唯一标识，可通过environments标签中的default设置某一个环境的id，表示默认使用的环境
-->
<environment id="development">transactionManager标签
<!--
transactionManager：设置事务管理方式
属性：
type：设置事务管理方式，type="JDBC|MANAGED"
type="JDBC"：设置当前环境的事务管理都必须手动处理
type="MANAGED"：设置事务被管理，例如spring中的AOP
-->
<transactionManager type="JDBC"/>properties标签
<properties resource="jdbc.properties"></properties>
<!-- 引用配置文件 -->dateSource标签
<!--
dataSource：设置数据源
属性：
type：设置数据源的类型，type="POOLED|UNPOOLED|JNDI"
type="POOLED"：使用数据库连接池，即会将创建的连接进行缓存，下次使用可以从缓存中直接获取，不需要重新创建
type="UNPOOLED"：不使用数据库连接池，即每次使用连接都需要重新创建
type="JNDI"：调用上下文中的数据源
-->
<dataSource type="POOLED">property标签
<!--设置驱动类的全类名-->
<property name="driver" value="${jdbc.driver}"/>
<!--设置连接数据库的连接地址-->
<property name="url" value="${jdbc.url}"/>
<!--设置连接数据库的用户名-->
<property name="username" value="${jdbc.uname}"/>
<!--设置连接数据库的密码-->
<property name="password" value="${jdbc.password}"/>mapper标签
<mappers>
<!-- 以具体的xml为单位引入核心配置文件 -->
<!-- <mapper resource="com.seven.mybatis.mapper.UserMapper.xml"/>-->
<!--
以包为单位，将包下所有的映射文件引入核心配置文件
注意：
1. 此方式必须保证mapper接口和mapper映射文件必须在相同的包下
2. mapper接口要和mapper映射文件的名字一致
-->
<package name="com.seven.mybatis.mapper"></package>
</mappers>不好意思！开学比较忙马上更新9.22
若mapper接口方法的参数为多个字面量类型
此时mybatis会把参数放到map集合中，以两种方式存储
因此只需要通过#{}和${}访问map集合的键，就可以获取相对应的值，一定要注意${}的单引号问题。
若mapper接口方法的参数为map集合类型的参数
只需通过#{}和${}访问map集合的键，就可以获得相对应的值，一定要注意${}的单引号问题。
若mapper接口方法的参数为实体类类型的参数
只需要通过#{}和${}访问实体类中的属性名，就可以获得相对应的属性值，一定要注意${}的单引号问题。
可以在mapper接口方法的参数上设置@param注解
此时mybatis会把这些参数放到map中，以两种方式进行存储。
只需要通过#{}和${}访问map集合的键，就可以获取相应的值，一定要注意${}的单引号问题
根据ID获取User对象
/**
* 通过id获取用户数据
* @param id
* @return
*/
User getUserById(@Param("id") Integer id); <!-- User getUserById(@Param("id") Integer id); -->
<select id="getUserById" resultType="User">
select * from t_user where id = #{id}
</select>查询所有t_user表的数据
/**
* 获取所有用户数据
* @return
*
* 如果获取表中所有的数据需要list集合接收
*
*/
List<User> getAllUser();
/**
* 获取所有用户数据
* @return
* 如果用实体类对象接收则会报错 报错信息为
* org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null)
* to be returned by selectOne(), but found: 5
* 期望返回一个结果发现返回5条数据
*/
User getAllUser();<!-- List<User> getAllUser(); -->
<select id="getAllUser" resultType="User">
select * from t_user
</select>
<!-- User getAllUser(); -->
<select id="getAllUser" resultType="User">
select * from t_user
</select>利用map集合获取数据
/**
* 用map集合获取数据
* @param id
* @return
* 以字段名为键 以字段的值为值 如果某一字段值为null 则不会放到map集合中
*/
Map<String,Object> getAllUserByMap(@Param("id") Integer id); <!-- Map<String,Object> getAllUserByMap(@Param("id") Integer id); -->
<select id="getAllUserByMap" resultType="map">
select * from t_user where id =#{id}
</select>利用map集合获取全部数据
/**
* 用map集合获取数据mapKey为键 以获取到的数据为值
* @return
*/
@MapKey("id")
Map<String,Object> getAllUserByMaps(); <!-- Map<String,Object> getAllUserByMaps(); -->
<select id="getAllUserByMaps" resultType="map">
select * from t_user
</select>2022年9月25日 星期日 23：20：55