测开学习笔记十二：mybaits&springboot入门

最新推荐文章于 2022-12-23 15:03:53 发布

qq_33214066

最新推荐文章于 2022-12-23 15:03:53 发布

阅读量165

点赞数

分类专栏： Java测开学习笔记文章标签： java spring boot

本文链接：https://blog.csdn.net/qq_33214066/article/details/120349396

版权

Java测开学习笔记专栏收录该内容

11 篇文章 6 订阅

订阅专栏

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

启动程序测试：
在这里插入图片描述

qq_33214066

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
测开学习笔记十二：mybaits&springboot入门

1.mybatis1.1mybatis简介MyBatis是一款优秀的基于ORM的半自动轻量级持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的 XML或注解来配置和映射原生类型、接口和Java的POJO (Plain Old Java Objects,普通老式Java对象) 为数据库中的记录。1.2 mybatis 优势Mybatis是一个半自动化的持久层框架，对开发人员开说，核心sql还是需
复制链接

扫一扫