1.mybatis
1.1mybatis简介
MyBatis是一款优秀的基于ORM的半自动轻量级持久层框架,它支持定制化SQL、存储过程以及高级映 射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的 XML或注解来配置和映射原生类型、接口和Java的POJO (Plain Old Java Objects,普通老式Java对 象) 为数据库中的记录。
1.2 mybatis 优势
Mybatis是一个半自动化的持久层框架,对开发人员开说,核心sql还是需要自己进行优化,sql和java编码进行分离,功能边界清晰,一个专注业务,一个专注数据。
1.3 mybatis快速入门
开发步骤:
1.搭建依赖环境
<?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">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>mybatis</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!--mybatis坐标--> <dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.4.5</version>
</dependency>
<!--mysql驱动坐标--> <dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
<scope>runtime</scope>
</dependency>
<!--单元测试坐标-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--日志坐标-->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.16</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.60</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>
2编写User实体类
package com.pojo;
import lombok.Data;
@Data
public class User {
public int id;
public String name;
public String age;
}
3.编写dao层
package com.dao;
import com.pojo.User;
import java.util.List;
public interface UserDao {
List<User> findAll();
}
4编写映射文件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.dao.UserDao">
<select id="findAll" resultType="com.pojo.User">
select * from User
</select>
</mapper>
5编写核心文件sqlConfig.xml
<?xml version="1.0" encoding="UTF-8" ?><!--加载外部的properties文件-->
<properties resource="jdbc.properties"/>
<!--environments:运行环境-->
<environments default="development">
<environment id="development">
<!--当前事务交由JDBC进行管理-->
<transactionManager type="JDBC"/>
<!--当前使用mybatis提供的连接池-->
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
<!--引入映射配置文件-->
<mappers>
<mapper resource="UserMapper.xml"/>
</mappers>
</configuration>
6.编写测试类
package com.mybatis.learn;
import com.dao.UserDao;
import com.pojo.User;
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;
import java.util.List;
public class MybatisTest {
@Test
public void testProxyDao() throws IOException {
//加载核心配置文件
InputStream resourceAsStream = Resources.getResourceAsStream("sqlConfig.xml");
//获得sqlSession工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
//获得sqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession(); //获得MyBatis框架生成的UserMapper接口的实现类
UserDao userMapper = (sqlSession).getMapper(UserDao.class);
List<User> users = userMapper.findAll();
System.out.println(users);
sqlSession.close();
}
}
2. Spring+SpringMVC+MyBatis
在mybatis框架体系中,主要的组件是:SqlSessionFactoryBean和MapperScannerConfigurer。SqlSessionFactoryBean类依赖外部注入的数据源:DataSource。并有两个属性:configLocation和mapperLocations。
ConfigLocation指定了mybatis配置文件的位置;mapperLocations指定了多个mapper映射文件的位置。
MapperSacannerConfigurer依赖SqlSessionFactoryBean,并根据basePackages属性指定的IDao接口类所在的包位置,自动扫描该包路径,为每个IDao类创建一个MapperFactoryBean类。MapperFactoryBean类会为它所对应的IDao接口类创建其具体的实现类实例,并将其注入到service层的业务代码中。
2.1 快速入门
sping-mybatis.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 自动扫描 -->
<context:component-scan
base-package="com.cn.hnust" />
<!-- 引入配置文件 -->
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:jdbc.properties" />
</bean>
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClass}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<!-- 初始化连接大小 -->
<property name="initialSize" value="${jdbc.initPoolSize}"></property>
<!-- 连接池最大数量 -->
<property name="maxActive" value="${jdbc.maxPoolSize}"></property>
</bean>
<!-- spring和MyBatis整合 -->
<bean id="sqlSessionFactory"
class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:mybatis-config.xml" />
<!-- 自动扫描mapping.xml文件 -->
<property name="mapperLocations"
value="classpath:com/cn/hnust/mapping/*.xml"/>
</bean>
<!-- DAO接口所在包名,Spring会自动查找其下的类 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.cn.hnust.dao" />
<property name="sqlSessionFactoryBeanName"
value="sqlSessionFactory"/>
</bean>
<!-- (事务管理)transaction manager, use JtaTransactionManager for global tx -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
</beans>
package com.cn.hnust.dao;
import com.cn.hnust.pojo.User;
import java.util.List;
public interface IUserDao {
List<User> findAll();
int insert(User record);
int insertSelective(User record);
int updateByPrimaryKeySelective(User record);
}
<?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.cn.hnust.dao.IUserDao" >
<resultMap id="BaseResultMap" type="com.cn.hnust.pojo.User" >
<id column="id" property="id" jdbcType="INTEGER" />
<result column="user_name" property="userName" jdbcType="VARCHAR" />
<result column="password" property="password" jdbcType="VARCHAR" />
<result column="age" property="age" jdbcType="INTEGER" />
</resultMap>
<select id="findAll" resultType="com.cn.hnust.pojo.User">select * from User</select>
<insert id="insert" parameterType="com.cn.hnust.pojo.User" >
insert into user (id, user_name, password, age)
values (#{id}, #{userName}, #{password}, #{age})
</insert>
<insert id="insertSelective" parameterType="com.cn.hnust.pojo.User" >
insert into user
<trim prefix="(" suffix=")" suffixOverrides="," >
<if test="id != null" >
id,
</if>
<if test="userName != null" >
user_name,
</if>
<if test="password != null" >
password,
</if>
<if test="age != null" >
age,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides="," >
<if test="id != null" >
#{id,jdbcType=INTEGER},
</if>
<if test="userName != null" >
#{userName,jdbcType=VARCHAR},
</if>
<if test="password != null" >
#{password,jdbcType=VARCHAR},
</if>
<if test="age != null" >
#{age,jdbcType=INTEGER},
</if>
</trim>
</insert>
<update id="updateByPrimaryKeySelective" parameterType="com.cn.hnust.pojo.User" >
update user
<set >
<if test="userName != null" >
user_name = #{userName,jdbcType=VARCHAR},
</if>
<if test="password != null" >
password = #{password,jdbcType=VARCHAR},
</if>
<if test="age != null" >
age = #{age,jdbcType=INTEGER},
</if>
</set>
where id = #{id,jdbcType=INTEGER}
</update>
</mapper>
单元测试:
package com.cn.hnust.dao;
import com.cn.hnust.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring-mybatis.xml"})
public class IUserDaoTest {
@Autowired
IUserDao userDao;
@Test
public void select(){
List<User> userList=userDao.findAll();
System.out.println(userList);
}
@Test
public void insert(){
User record =new User();
record.setId(3);
//record.setUserName("alisa");
record.setPassword("test");
record.setAge(22);
userDao.insert(record);
}
@Test
public void insertNotNUll(){
User record =new User();
//record.setUserName("alisa");
record.setPassword("test");
record.setAge(22);
userDao.insertSelective(record);
}
@Test
public void update(){
User user1 =new User();
user1.setId(3);
user1.setUserName("test11111");
userDao.updateByPrimaryKeySelective(user1);
}
}
https://www.cnblogs.com/wolf-lifeng/p/11153569.html
3.使用mybatis-generator-maven-plugin自动生成代码
3.1.在pom.xml里引入插件
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.7</version>
<!-- 添加一个mysql的依赖,防止等会找不到driverClass -->
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.driver.version}</version>
<scope>runtime</scope>
</dependency>
</dependencies>
<!-- mybatisGenerator 的配置 -->
<configuration>
<!-- generator 工具配置文件的位置 -->
<configurationFile>src/main/resources/generatorConfig.xml</configurationFile>
<!-- 是否覆盖 -->
<!-- 此处要特别注意,如果不加这个设置会导致每次运行都会在原目录再次创建-->
<overwrite>true</overwrite>
</configuration>
</plugin>
3.2 新建generatorConfig.xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd" >
<generatorConfiguration>
<properties resource="jdbc.properties" />
<!-- 指定数据连接驱动jar地址 -->
<classPathEntry location="${jdbc.driverPath}" />
<!-- 此处指定生成针对MyBatis3的DAO -->
<context id="context" targetRuntime="MyBatis3">
<!-- 生成的Java文件的编码 -->
<property name="javaFileEncoding" value="UTF-8"/>
<!-- 格式化java代码 -->
<property name="javaFormatter" value="org.mybatis.generator.api.dom.DefaultJavaFormatter"/>
<!-- 格式化XML代码 -->
<property name="xmlFormatter" value="org.mybatis.generator.api.dom.DefaultXmlFormatter"/>
<!--beginningDelimiter和endingDelimiter:指明数据库的用于标记数据库对象名的符号,比如ORACLE就是双引号,MYSQL默认是`反引号;-->
<property name="beginningDelimiter" value="`"/>
<property name="endingDelimiter" value="`"/>
<!-- 为生成的Java模型创建一个toString方法 -->
<plugin type="org.mybatis.generator.plugins.ToStringPlugin" />
<!-- 添加序列号方法 -->
<plugin type="org.mybatis.generator.plugins.SerializablePlugin" />
<!-- 重命名插件 -->
<plugin type="org.mybatis.generator.plugins.EqualsHashCodePlugin" />
<!-- <plugin type="org.mybatis.generator.plugins.RenameExampleClassPlugin"> -->
<!-- <property name="searchString" value="Example$" /> -->
<!-- <property name="replaceString" value="Criteria" /> -->
<!-- </plugin> -->
<!-- 去掉生成出来的代码的注解 -->
<commentGenerator>
<property name="suppressAllComments" value="true" />
<property name="suppressDate" value="true" />
</commentGenerator>
<!--数据库链接URL,用户名、密码 -->
<jdbcConnection driverClass="${jdbc.driverClass}"
connectionURL="${jdbc.url}" userId="${jdbc.username}" password="${jdbc.password}">
</jdbcConnection>
<!-- 默认false,表示把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer; true表示把JDBC DECIMAL
和 NUMERIC 类型解析为java.math.BigDecimal -->
<javaTypeResolver>
<property name="forceBigDecimals" value="false" />
</javaTypeResolver>
<!-- 生成bean对象 -->
<javaModelGenerator targetPackage="${target_package}.pojo"
targetProject="${project}">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="true" />
<!-- 从数据库返回的值被清理前后的空格 -->
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- 生成sqlMap xml -->
<sqlMapGenerator targetPackage="${target_package}.mapping"
targetProject="${project}">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- 生成DAO的类文件 -->
<javaClientGenerator targetPackage="${target_package}.dao"
targetProject="${project}" type="XMLMAPPER">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- <table tableName="user_t" domainObjectName="TUser"/> -->
<table tableName="user_t" domainObjectName="TUser2"
enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false"
selectByExampleQueryId="false">
</table>
</context>
</generatorConfiguration>
3.3 在maven里运行插件
3.4 两种生成语句
第一种:无example
<table tableName="user_t" domainObjectName="TUser2"
enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false"
selectByExampleQueryId="false">
</table>
第二种:有example,会生成实例及实例对应的example,example用于添加条件,相当where后面的部分
xxxExample example = new xxxExample();
Criteria criteria = new Example().createCriteria();
<table tableName="user_t" domainObjectName="TUser"/>
package com.cn.hnust.dao;
import com.cn.hnust.pojo.TUser;
import com.cn.hnust.pojo.TUser2;
import com.cn.hnust.pojo.TUserExample;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring-mybatis.xml"})
public class Tuser2Test {
@Autowired
TUser2Mapper tUser2Mapper;
@Autowired
TUserMapper tUserMapper;
@Test
public void insert(){
TUser2 tuser2=new TUser2();
tuser2.setAge("11");
tuser2.setId(6);
tUser2Mapper.insert(tuser2);
}
@Test
public void selectExample(){
TUserExample example=new TUserExample();
TUserExample.Criteria criteria=example.createCriteria();
criteria.andAgeEqualTo("19");
//criteria.andIdBetween(1,100);
//tUserMapper.countByExample(example);
//或的条件
TUserExample.Criteria criteria2=example.createCriteria();
criteria2.andAgeEqualTo("100");
example.or(criteria2);
tUserMapper.countByExample(example);
}
}
3.5分页
pom文件引入:
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.0.4</version>
</dependency>
@Test
public void testPage(){
PageHelper.startPage(3, 10);
TUserExample example =new TUserExample();
TUserExample.Criteria criteria = example.createCriteria();
criteria.andIdBetween(1,10000);
List<TUser> list= tUserMapper.selectByExample(example);
PageInfo<TUser> pageInfo=new PageInfo<>(list);
System.out.println(pageInfo.getTotal());
}
4.注解支持
package com.cn.hnust.dao;
import com.cn.hnust.pojo.User;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
public interface IUserDao {
int deleteByPrimaryKey(Integer id);
int insert(User record);
//动态sql
int insertSelective(User record);
User selectByPrimaryKey(Integer id);
int updateByPrimaryKeySelective(User record);
int updateByPrimaryKey(User record);
// $原始的拼接组装SQL,有安全问题
// #预编译
@Select("select * from user_t where user_name ='${username}'")
List<User> findUserByUsername(@Param("username") String username);
@Select("select * from user_t where user_name =#{username}")
List<User> findUserByUsername2(@Param("username") String username);
}
/**
* 保存用户 */
@Insert("insert into user(username, address, sex, birthday) values (#
{username}, #{address}, #{sex}, #{birthday})")
void saveUser(User user);
/**
* 更新用户 */
@Update("update user set username = #{username}, address = #{address}, sex=
#{sex}, birthday = #{birthday} where id = #{id}")
void updateUser(User user);
/**
* 删除用户 */
@Delete("delete from user where id = #{id}")
void deleteUser(Integer id);
5.事务
package com.cn.hnust.service.impl;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.cn.hnust.dao.IUserDao;
import com.cn.hnust.pojo.User;
import com.cn.hnust.service.IUserService;
@Service("userService")
public class UserServiceImpl implements IUserService {
@Resource
private IUserDao userDao;
@Override
public User getUserById(int userId) {
return this.userDao.selectByPrimaryKey(userId);
}
@Override
@Transactional //事务
public void insertUser(User user) {
userDao.insert(user);
throw new RuntimeException("test");//抛出unchecked异常,触发事物,回滚
}
}
单元测试:
package com.cn.hnust.dao;
import com.cn.hnust.pojo.User;
import com.cn.hnust.service.IUserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:spring-mybatis.xml"})
public class TransactionalTest {
@Autowired
IUserService iUserService;
@Test
@Transactional
//@Rollback(value = true)
public void transact(){
User user=new User();
user.setId(1110);
user.setUserName("leon01");
user.setAge(20);
user.setPassword("fds");
iUserService.insertUser(user);
}
}
6.Springboot
6.1Springboot概述
Spring Boot 并不是对 Spring 功能上的增强,而是提供了一种快速使用 Spring 的方式。
SpringBoot功能 :
- 自动配置
Spring Boot的自动配置是一个运行时(更准确地说,是应用程序启动时)的过程,考虑了众多因素,才 决定Spring配置应该用哪个,不该用哪个。该过程是SpringBoot自动完成的。 - 起步依赖
起步依赖本质上是一个Maven项目对象模型(Project Object Model,POM),定义了对其他库的传递
依赖,这些东西加在一起即支持某项功能。 简单的说,起步依赖就是将具备某种功能的坐标打包到一起,并提供一些默认的功能。 - 辅助功能 提供了一些大型项目中常见的非功能性特性,如嵌入式服务器、安全、指标,健康检测、外部配置等。
6.2 Springboot快速入门
1.创建Maven项目
2.导入SpringBoot起步依赖
<!--springboot工程需要继承的父工程--> <parent>
<groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.8.RELEASE</version>
</parent>
<dependencies>
<!--web开发的起步依赖--> <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId> </dependency>
</dependencies>
3.定义Controller
package springbootlearn.demo.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;
import java.util.HashMap;
import java.util.Map;
@RestController
@RequestMapping("/home")
public class HomeController {
@GetMapping("/test")
public Object test(){
Map<String,String> map =new HashMap<>();
map.put("hello","spring boot ------");
return map;
}
}
4.编写引导类
/**
* 引导类。 SpringBoot项目的入口 */
@SpringBootApplication
public class HelloApplication {
public static void main(String[] args) { SpringApplication.run(HelloApplication.class,args);
} }
5.启动测试
6.3 thymeleaf快速入门
1.导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
2.修改配置文件
#thymeleaf配置文件
spring.thymeleaf.prefix=classpath:/templates/
spring.thymeleaf.suffix=.html
3.编写Controller类
package springbootlearn.demo.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;
import java.util.HashMap;
import java.util.Map;
@RestController
@RequestMapping("/home")
public class HomeController {
@GetMapping("/learn")
public ModelAndView learn(){
ModelAndView modelAndView=new ModelAndView("index");
modelAndView.addObject("msg","hello,#thymeleaf!");
return modelAndView;
}
}
4.编写html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Thymeleaf入门</title>
</head>
<body>
Thymeleaf入门
<span>${msg}</span>
<hr/>
<span th:text="${msg}"></span>
<hr/>
<input type="text" name="username" th:value="${msg}"/>
<hr/>
</body>
</html>
5.接口测试
6.4 引入数据库查询数据
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!-- MySQL连接 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
@GetMapping("/learn3")
public ModelAndView learn3(){
ModelAndView modelAndView=new ModelAndView("index3");
String sql = "select * from idcard_infos";
RowMapper<IdCard> rowMapper = new BeanPropertyRowMapper<>(IdCard.class);
List<IdCard> users = jdbcTemplate.query(sql, rowMapper);
modelAndView.addObject("userList",users);
return modelAndView;
}
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<table border="1">
<tr>
<th>Index</th>
<th>ID</th>
<th>Name</th>
<th>Age</th>
</tr>
<tr th:each="u,var : ${userList}">
<td th:text="${var.count}"></td>
<td th:text="${u.phone}"></td>
<td th:text="${u.idcard}"></td>
<td th:text="${u.color}"></td>
</tr>
</table>
</body>
</html>
配置文件配置数据源
#自动配置datasource
spring.datasource.username=uquest_ddl
spring.datasource.password=7hfxpa
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc\:mysql\://172.0.0.1\:3307/mytest_zou?characterEncoding=utf-8&useSSL=false
启动程序测试: