SSM框架--笔记
目录
一
一,Maven
–1,创建maven工程
二,Maven
–1,概述
–2,使用Maven
–3,IDEA里配置Maven
–4,创建Maven项目
–5,添加jar包的依赖
三,Spring Boot
–1,概述
–2,创建Spring Boot项目
–3,给服务器添加资源
–4,测试
二
一,SpringMVC
–1,概述
–2,原理
–3,创建Module
–4,入门案例
二,SpringMVC的响应
–1,概述
–2,测试
三,SpringMVC解析get请求的参数
–1,概述
–2,测试
三
一,SpringMVC解析restful的请求参数
–1,概述
–2,测试
二,SpringMVC解析post的请求参数
–0,项目结构
–1,准备form表单
–2,准备Student类
–3,准备StudentController类
–4,利用jdbc把接受到的参数入库
–5,测试
–6,总结
三,Git
–1,概述
–2,常用命令
–3,使用步骤
–4,检查
–5,日常操作
四
一,Spring
–1,概述
–2,IOC的XML实现方式
–3,IOC的注解实现方式
4,Spring的DI 依赖注入
–1,概述
–2,简单模拟
–3,使用Spring实现DI
五
一,Lombok
–1,概述
–2,使用步骤
二,热部署
–1,概述
–2,步骤
三,两框架整合
–0,项目结构
–1,概述
–2,创建网页
–3,创建RunApp类,启动服务器
–4,创建Car类
–5,创建CarController类
–6,创建CarService接口
–7,创建CarServiceImpl实现类
–8,测试
–9,总结
六
一,AOP
–1,概述
–2,步骤
二,Ajax
–1,概述
–2,步骤
三，Mybatis
–1,概述
–2,核心资源
–3,入门案例
七
一,Mybatis入门案例
–0,导入mybatis的jar包
–1,核心配置文件
–2,映射文件
–3,创建User类
–4,测试类
5，总结
二,Mybatis的练习
–1,修改映射文件UserMapper.xml
–2,修改测试类
–3,总结
三,优化配置
–1,别名
四,接口开发
–1,概述
–2,使用
–3,改造
五,练习接口开发
–1,修改 接口文件
–2,修改 映射文件
–3,修改 测试文件
六,动态SQL
–1,概述
–2,修改映射文件,实现动态SQL
八
一,动态SQL
–1,foreach标签
二,ResultMap
–1,概述
–2,测试
3,优化简化resultmap
三,SSM整合
–0,准备表和数据
–0,添加mybatis的jar包
–1,创建前端HTML网页
–2,创建启动类RunApp
–3,创建配置文件application.yml
–4,创建pojo类
–5,创建CarMapper接口
–6,创建映射文件CarMapper.xml
–7,创建CarService接口
–8,创建CarServiceImpl实现类
–9,创建CarController类
–10,测试
–11,总结
一
一,Maven
–1,创建maven工程
1,File-New-Project-选中Maven-next-输入工程名和GroupId-Finish
2,打开pom.xml文件,添加jar包的位置,交给Maven下载
4.0.0
cn.tedu
cgb2106maven01
1.0-SNAPSHOT
mysql
mysql-connector-java
5.1.48
3,必须刷新,否则不下载
二,Maven
–1,概述
用来下载并且管理jar包的工具,用来构建项目的方式
仓库:
中央仓库/远程仓库: 本质上就是一个国外的网址
镜像仓库: 其实就是一个国内的网址,人家从中央仓库下载好了jar包,你可以直接用
本地仓库: 其实就是你自己定的一个文件夹的位置,用来存jar包的位置
依赖:
Maven会自动下载并管理相关的jar
坐标:
通过Maven下载很多的jar包,唯一的定位方式就是使用坐标.
GroupId: 通常指定组,值一般是指公司的域名
ArtifactId: 通常项目名称
Version: 是指版本号
命令:
maven提供了很多命令,常用的有clean , install
–2,使用Maven
1,解压Maven的压缩包
2,找到conf文件夹里的settings.xml文件,修改
3,修改两个地方:
本地仓库: 指定一个jar包的存放路径
镜像仓库: 指定一个从哪里下载jar包的网址
4,settings.xml文件代码如下
D:\Java\maven\resp
ali
ali Maven
*
https://maven.aliyun.com/repository/public/
–3,IDEA里配置Maven
1,找到Maven设置的位置: File-Settings-选Builder,execution…-Build Tools-选择Maven
2,配置信息:
指定maven解压的位置
指定解压文件里的conf/settings.xml文件
指定本地仓库(IDEA自动完成)
3,以上操作,避免了jar包自动下载到默认位置C:\Users\Administrator.m2\repository占用系统空间的现象
–4,创建Maven项目
1,File-New-Project-选择Maven-next-输入工程名/GroupId-ok
2,通常创建好项目以后,第一步就是配置Maven,不然就把jar包都下载到了C盘.
3,IDEA里配置Maven(同上)
–5,添加jar包的依赖
1,修改pom.xml文件,使用dependencies标签,引入各种jar包.
2,指定jar包的坐标,Maven会自动下载.
3,检查本地仓库
三,Spring Boot
–1,概述
是一个Maven项目的延伸,也拥有pom.xml
优势: 简化了Maven的操作 , 嵌入了Tomcat
–2,创建Spring Boot项目
1, File-New-Project-选择Spring Initlize-next-输入Group名和Artifact名和选择java8
-next-选中Spring(Spring Web)-next-ok
2, 配置Maven
3,检查:
–3,给服务器添加资源
package cn.tedu.cgb2106boot01;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloBoot {
@RequestMapping("abc")
public String hello(){
return "hello spring boot";
}
}
–4,测试
1,开启服务器(运行main方法)
2,打开浏览器访问:
http://localhost:8080/abc
本机 端口号 要访问的资源
二
一,SpringMVC
–1,概述
框架: 是一个结构,框架提供了很多的类,由框架控制每个类调用的过程流程
SSM框架里,第一个S就是指SpringMVC,是一个框架.
是Spring框架的一个后续产品,遵循了MVC的设计模式,保证了程序间的松耦合.
SpringMVC主要作用:1,接受请求(解析请求参数) 2,做出响应
MVC的设计模式:
M是Model模型,用来封装数据
V是View视图,用来展示数据
C是Controller控制器,用来控制浏览器如何请求,做出数据响应
好处: 提高代码的复用性 , 松耦合
–2,原理
1,前端控制器DispatcherServlet:
当浏览器发送请求成功后,充当这调度者的角色,负责调度每个组件.
2,处理器映射器HandlerMapping:
根据请求的URL路径,找到能处理请求的类名和方法名
url: http://localhost:8080/hi , 找到Hello类里的hi()
3,处理器适配器HandlerAdapter:
正式开始处理业务,并把返回结果的结果交给DispatcherServlet
4,视图解析器ViewResolver:
找到正确的,能展示数据的视图,准备展示数据
5,视图渲染View:
展示数据
–3,创建Module
选中Project-右键-New-Module-选择Maven-next-输入Module的名字-next-finish
–4,入门案例
1, 导入jar包(被Spring Boot整合好了)
2, 准备一个启动类RunApp,用来启动服务器
package cn.tedu.mvc;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//标记着这是springboot的启动类
@SpringBootApplication
public class RunApp {
public static void main(String[] args) {
SpringApplication.run(RunApp.class);//运行当前类
}
}
3, 准备一个类,补充方法
访问链接： http://localhost:8080/car/get
得到数据：123
package cn.tedu.mvc;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
//完成springmvc的角色,接受请求和给出响应
//是MVC设计模式里的C控制器,接受请求和给出响应
@RestController
//标记着这个类是Controller是一个控制器+接受请求
@RequestMapping("car")//规定了url怎么访问这个类
public class HelloController {
//测试： http://localhost:8080/car/get
@RequestMapping("get")//规定了url怎么访问这个方法
public String show(){
return "123";
}
}
4, 测试
启动服务器,打开浏览器,访问正确的URL地址
二,SpringMVC的响应
–1,概述
SpringMVC可以接受请求,和做出响应数据,类型可以非常丰富
–2,测试
package cn.tedu.mvc;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
//完成springmvc的角色,接受请求和给出响应
//是MVC设计模式里的C控制器,接受请求和给出响应
@RestController
//标记着这个类是Controller是一个控制器+接受请求+响应JSON串
@RequestMapping("car")//规定了url怎么访问这个类
public class HelloController {
//测试： http://localhost:8080/car/get
@RequestMapping("get")//规定了url怎么访问这个方法
public String show(){
return "123";
}
//测试： http://localhost:8080/car/abc
@RequestMapping("abc")
public int show2(){
return 100;
}
// SpringMVC框架除了能返回字符串,整数以外,还能返回对象信息
//测试： http://localhost:8080/car/get2
@RequestMapping("get2")
public Car get(){
Car c = new Car();
//给客户端准备数据
c.setId(718);
c.setName("保时捷");
c.setType("Cayman T");
c.setColor("红色");
c.setPrice(641000);
return c; //把对象信息 变成JSON字符串在浏览器展示
}
}
三,SpringMVC解析get请求的参数
–1,概述
请求方式8种,常见的就是get post
restful风格的数据,用来简化了get的写法
http://localhost:8080/car/insert?id=1&name=张三&age=18
http://localhost:8080/car/insert/1/张三/18
–2,测试
package cn.tedu.mvc;
import org.junit.Test;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
//Springmvc解析get的请求参数
// http://localhost:8080/car/insert?id=1&name=张三&age=18
@RestController//接受请求做出响应
@RequestMapping("get")//规定了浏览器的访问方式
public class GetController{
//测试 http://localhost:8080/get/param4?id=100&name=BMW&type=X6&color=red&price=9.9
@RequestMapping("param4")
//public String param4(int id,String name,String type,String color,double price){
public Car param4(Car c){//直接用对象接受参数,框架会自动封装属性的值
return c;
}
//测试 http://localhost:8080/get/param3?id=100&name=张三&price=9.9
@RequestMapping("param3")
public String param3(int id,String name,double price){
return id+name+price;
}
//测试 http://localhost:8080/get/param2?id=100&name=张三
@RequestMapping("param2")
public void param2(int id,String name){
System.out.println(id);
System.out.println(name);
}
//测试 http://localhost:8080/get/param?id=100
@RequestMapping("param")
public String param(int id){
return "您的请求参数里id="+id ;
}
@Test //单元测试方法
public void get1(){
String url ="http://localhost:8080/car/insert?id=1&name=张三&age=18";
String[] a = url.split("\\?")[1].split("&");
for(String s : a){
String data = s.split("=")[1];
System.out.println(data);
}
}
}三
一,SpringMVC解析restful的请求参数
–1,概述
简化了get方式参数的写法
普通的get传递的参数 http://localhost:8080/car/get?id=100&name=张三
restful传递的参数 http://localhost:8080/car/get2/100/张三
–2,测试
创建RunApp启动类
package cn.tedu;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//位置:必须在所有资源之上的包里
@SpringBootApplication
public class RunApp {
public static void main(String[] args) {
SpringApplication.run(RunApp.class);
}
}
创建CarController类
package cn.tedu.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
//@Controller
//@ResponseBody
@RestController
@RequestMapping("car")
public class CarController {
//注意1:: 参数列表里的参数类型,最好使用引用类型,
//如果浏览器没有传值过来就用默认值,但使用基本类型会抛异常的
//解析普通的get传递的参数
//http://localhost:8080/car/get?id=100&name=张三
@RequestMapping("get")
// public String get(int id,String name){
public String get(Integer id,String name){
return id+name ;
}
//解析restful传递的参数:简化了get方式参数的写法
//http://localhost:8080/car/get2/100/张三
@RequestMapping("get2/{id}/{name}")
//{x}--通过{}获取访问路径中携带的参数,并且交给变量x保存
//@PathVariable -- 获取{}中间变量的值
public String get2(@PathVariable Integer id,
@PathVariable String name){
return id+name;
}
//http://localhost:8080/car/get3/100/张三/red/9.9
@RequestMapping("get3/{a}/{b}/{c}/{d}")
public String get3(@PathVariable Integer a,
@PathVariable String b,
@PathVariable String c,
@PathVariable double d){
return a+b+c+d ;
}
}
创建前端网页文件
测试
二,SpringMVC解析post的请求参数
–0,项目结构
–1,准备form表单
–2,准备Student类
package cn.tedu.pojo;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Arrays;
import java.util.Date;
//是Model层,用来封装数据,就是一个pojo(封装的属性+get/set)
public class Student {
//属性(成员变量):变量类型 变量名
//提交数据的类型 页面上name属性的值
private String name ;
private Integer age ;//避免了一些异常
private Integer sex ;
private String[] hobby ;
private Integer edu ;
//浏览器上提交的日期默认是String类型,2012/8/12,报错400
//@DateTimeFormat把String的日期转成Date日期
//pattern属性规定了日期的格式y表示年M表示月d表示日
@DateTimeFormat(pattern="yyyy-MM-dd")
private Date intime;
//get set tostring
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Integer getSex() {
return sex;
}
public void setSex(Integer sex) {
this.sex = sex;
}
public String[] getHobby() {
return hobby;
}
public void setHobby(String[] hobby) {
this.hobby = hobby;
}
public Integer getEdu() {
return edu;
}
public void setEdu(Integer edu) {
this.edu = edu;
}
public Date getIntime() {
return intime;
}
public void setIntime(Date intime) {
this.intime = intime;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
", hobby=" + Arrays.toString(hobby) +
", edu=" + edu +
", intime=" + intime +
'}';
}
}
–3,准备StudentController类
package cn.tedu.controller;
import cn.tedu.pojo.Student;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
//是C层,控制层,用来接受请求和给出响应
@RestController
@RequestMapping("stu")
public class StudentController {
@RequestMapping("add")
public Object add(Student s){
//TODO 实现入库insert
return s;
}
}
–4,利用jdbc把接受到的参数入库
操作cgb2106的库, 创建tb_student表(参考Student类)
CREATE TABLE tb_student(
id INT PRIMARY KEY AUTO_INCREMENT,
NAME VARCHAR(50),
age INT,
sex INT,
hobby VARCHAR(100),
edu INT,
intime DATE
)
修改pom.xml文件,添加jdbc的jar包的坐标
cgb2106boot03
cn.tedu
0.0.1-SNAPSHOT
4.0.0
day14
mysql
mysql-connector-java
5.1.48
写jdbc的代码
package cn.tedu.controller;
import cn.tedu.pojo.Student;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.util.Arrays;
//是C层,控制层,用来接受请求和给出响应
@RestController
@RequestMapping("stu")
public class StudentController {
@RequestMapping("add")
public Object add(Student s) throws Exception {
//TODO 利用jdbc,实现入库
//注册驱动
Class.forName("com.mysql.jdbc.Driver");
//获取连接
String url="jdbc:mysql:///cgb2106?characterEncoding=utf8";
Connection conn = DriverManager.getConnection(url,"root","root");
//获取传输器
String sql = "insert into tb_student values(null,?,?,?,?,?,?)";
PreparedStatement ps = conn.prepareStatement(sql);
//给SQL设置参数
ps.setObject(1,s.getName());
ps.setObject(2,s.getAge());
ps.setObject(3,s.getSex());
//s.getHobby()得到一个数组,不能直接存入数据库,需要变成串入库
ps.setObject(4, Arrays.toString( s.getHobby() ) ) ;
ps.setObject(5,s.getEdu());
ps.setObject(6,s.getIntime());
//执行SQL
ps.executeUpdate();//执行增删改的SQL
System.out.println("数据插入成功!");
return s;
}
}
–5,测试
–6,总结
三,Git
–1,概述
是一个版本控制产品,用来实现资源的版本控制.
可以把资源随时上传到Git上,可以随时拉取下载
好处: 快速恢复到历史版本. 容错性高.
远程仓库: 是指 Gitee官网 的网址,存你已经传上去的资源
本地仓库: 是指你磁盘里的一个路径,存你即将要上传的资源
本地索引: 是指将要提交的数据建立索引,方便查找定位
工作空间: 保存了资源的位置
过程: 工作空间 -> 本地索引 -> 本地仓库 -> 远程仓库
–2,常用命令
add: 把工作空间的资源,添加到 本地索引
commit: 把本地索引的资源 提交到 本地仓库
push: 把本地仓库的资源 推送到 远程仓库
pull/clone: 把资源从远程仓库下载下来
–3,使用步骤
1, 安装Git软件
2, 在Gitee官网注册账号,使用账号上传资源
3, 创建本地仓库, 就是在你的磁盘里建一个文件夹,存放即将上传的资源
仅供参考: D:\workspace\gitee\cgb2106
4, 创建远程仓库, 去Gitee官网创建,存本地仓库上传的资源
Gitee官网右上角的加号,点新建仓库,设置仓库名称选成开源,ok
5, 需要在本地仓库那里,执行一些Git命令.
git config --global user.name "cgblpx" #设置了Gitee注册的用户名
git config --global user.email "[email protected]" #设置了Gitee注册的邮箱
git config --list # 查看设置信息
git init #初始化一个Git的环境
#在你的本地仓库创建一个文件,准备上传它
git add 1.txt #添加,从工作空间到本地索引
git commit -m "first commit" #从本地索引提交到本地仓库
git remote add origin https://gitee.com/cgblpx/cgb2106test.git
#添加到指定远程仓库里
git push -u origin master #从本地仓库推送到远程仓库
Username for 'https://gitee.com': #输入自己注册的账号
Password for 'https://[email protected]': #输入自己注册的密码
–4,检查
刷新Gitee官网就有刚传上去的资源啦
- 1
–5,日常操作
1, 把你要提交的资源拷贝到 本地仓库
2, 在本地仓库处, 执行以下Git命令提交资源
3, 把远程仓库的资源下载到本地
git add .
git commit -m "test"
git push -u origin master
git clone 再加上要下载的资源的网址四
一,Spring
–1,概述
功能非常丰富,核心的功能是: IOC DI AOP
IOC : 是控制反转,指 把创建对象的过程交给了Spring
DI : 是依赖注入,指把对象间的依赖关系 自动维护
AOP : 是补充了OOP的不足
–2,IOC的XML实现方式
是指把创建对象管理对象的过程交给了Spring框架
创建Maven Module
File-New-Module-Maven-next-输入ModuleName-ok
导入jar包(不需要了,被Spring Boot整合了)
创建Hello类
创建配置文件
测试
package cn.tedu.test;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test1 {
@Test
public void get(){
//1,读取配置文件
ClassPathXmlApplicationContext spring =
new ClassPathXmlApplicationContext(
"spring-config.xml");
//2,直接getBean
Object o = spring.getBean("hello");
System.out.println(o);//cn.tedu.spring.Hello@45752059
}
}
–3,IOC的注解实现方式
创建User类
package cn.tedu.ioc;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;
@Component("a")//自动完成IOC,自己指定bean的名字a -> {"a",new User()}
//@Component //默认的bean的名字,user
//@Component自动完成IOC, -> {"user",new User()}
//@Controller //spring提供的,用来ioc
//@Service //spring提供的,用来ioc
public class User {
public void get(){
System.out.println(123);
}
}
修改配置文件
测试
package cn.tedu.test;
import cn.tedu.ioc.User;
import cn.tedu.spring.Hello;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test1 {
@Test
public void get(){
//1,读取配置文件
ClassPathXmlApplicationContext spring =
new ClassPathXmlApplicationContext(
"spring-config.xml");
//2,直接getBean
Object o = spring.getBean("hello");
System.out.println(o);//cn.tedu.spring.Hello@45752059
//调用子类的方法--向下转型/造型
Hello h = (Hello) o ;
h.get();
//获取注解的bean
User u = (User) spring.getBean("a");
System.out.println(u);//cn.tedu.ioc.User@28f3b248
}
}
总结
4,Spring的DI 依赖注入
–1,概述
是指对象间的依赖关系,可以由框架来完成
–2,简单模拟
创建Dept类
package cn.tedu.di;
public class Dept {
String name="java软件开发一部";
@Override
public String toString() {
return "Dept{" +
"name='" + name + '\'' +
'}';
}
}
创建Emp类
package cn.tedu.di;
public class Emp {
String name="jack";
//绑定两个类间的关系
private Dept d ;
public Dept getD() {
return d;
}
public void setD(Dept d) {
this.d = d;
}
@Override
public String toString() {
return "Emp{" +
"name='" + name + '\'' +
", d=" + d +
'}';
}
}
测试
package cn.tedu.test;
import cn.tedu.di.Dept;
import cn.tedu.di.Emp;
import org.junit.jupiter.api.Test;
public class Test1 {
@Test
public void di(){
Dept d = new Dept();
System.out.println(d);//Dept{name='java软件开发一部'}
Emp e = new Emp();
System.out.println(e);//Emp{name='jack', d=null}
//di--把两个对象间的关系依赖注入
e.setD(d);
System.out.println(e);
//已经实现了di的效果,在查询e把关联的d的信息也查到了
//Emp{name='jack', d=Dept{name='java软件开发一部'}}
}
}
–3,使用Spring实现DI
创建Teacher类
package cn.tedu.di2;
import org.springframework.stereotype.Component;
@Component
public class Teacher {
String name = "tony";
@Override
public String toString() {
return "Teacher{" +
"name='" + name + '\'' +
'}';
}
}
创建Student类
package cn.tedu.di2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class Student {
String name = "蔡徐坤";
@Autowired //di
Teacher t ;
@Override
public String toString() {
return "Student{" +
"t=" + t +
", name='" + name + '\'' +
'}';
}
}
创建配置文件,包扫描
测试
@Test
public void di2(){
//1,读取xml文件
ClassPathXmlApplicationContext spring = new
ClassPathXmlApplicationContext(
"spring-config.xml");
//2,getBean
Object o = spring.getBean("student");
//di:查学生信息的同时也查到了老师信息,两个对象之间的依赖注入
//Student{t=Teacher{name='tony'}, name='蔡徐坤'}
System.out.println(o);
}五
一,Lombok
–1,概述
简化了Model层的代码的编写.
以前pojo类/实体类,需要自己提供set get toString equals hashCode
Lombok通过各种注解,简化了以上操作
@Data会自动生成set get toString equals hashCode
@NoArgsConstructor自动生成无参构造
@AllArgsConstructor自动生成全参构造
@Accessors(chain = true) //开启链式编程
–2,使用步骤
1, 在IDEA里安装插件
Settings-选Plugins-搜插件名-install
- 1
2, 修改pom.xml文件,添加lombok的jar包依赖
org.projectlombok
lombok
1.18.20
3, 修改pojo类
用lombok前
package cn.tedu.pojo;
public class Car {
private Integer id;
private String name;
private String color;
private Double price;
//get set tostring
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"id=" + id +
", name='" + name + '\'' +
", color='" + color + '\'' +
", price=" + price +
'}';
}
}
用lombok后
package cn.tedu.pojo;
//使用lombok
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data//自动生成get set tostring hashcode equals
@NoArgsConstructor//自动生成无参构造
@AllArgsConstructor//自动生成全参构造
@Accessors(chain = true)//开启链式编程
public class Student {
private Integer id;
private String name;
private String sex;
}
4, 测试
package cn.tedu.test;
import cn.tedu.pojo.Car;
import cn.tedu.pojo.Student;
import org.junit.jupiter.api.Test;
public class Test1 {
//测试lombok
@Test
public void get2(){
Student s = new Student();
Student s2 = new Student(200,"rose","女");
// s.setId(100);
// s.setName("jack");
// s.setSex("男");
//对set()可以使用lombok的链式编程
s.setId(100).setName("jack").setSex("男");
System.out.println(s);
System.out.println(s.getId()+s.getName()+s.getSex());
}
//测试Car
@Test
public void get(){
Car c = new Car();
c.setName("BMW");
String s = c.getName();
System.out.println(s);
c.setId(100);//自动装箱
Integer i = c.getId() ;
System.out.println(i);
System.out.println( c.getId() );
}
}
二,热部署
–1,概述
以前服务器改完代码,每次都需要重启服务器
现在只需要改完了重新build就行
–2,步骤
1, 添加jar包
org.springframework.boot
spring-boot-devtools
2.5.3
2, 开启IDEA的热部署的功能
按下组合键: ctrl + shift + alt + / 或者 ctrl + alt + a, 选中Registry, 选中自动编译, ok
- 1
3, 测试
创建RunApp启动类
package cn.tedu;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RunApp {
public static void main(String[] args) {
SpringApplication.run(RunApp.class);
}
}
创建StuController,接受请求处理响应
package cn.tedu.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("stu")
public class StuController {
@RequestMapping("get")
public String get(){
//热部署:改变成新的数据,也不必重启服务器了,只是build就可以啦
return "xyz";
}
}
4, 测试: 只要刷新,就可以获取新数据
http://localhost:8080/stu/get
- 1
三,两框架整合
–0,项目结构
–1,概述
–2,创建网页
测试 两个框架整合
请求服务器的数据
–3,创建RunApp类,启动服务器
package cn.tedu;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
//SpringBoot自动配置了包扫描:默认基于启动类所在的包
public class RunApp {
public static void main(String[] args) {
SpringApplication.run(RunApp.class);
}
}
–4,创建Car类
修改pom.xml,添加lombok的jar包
cgb2106boot03
cn.tedu
0.0.1-SNAPSHOT
4.0.0
day1602
org.projectlombok
lombok
1.18.20
Car类
package cn.tedu.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data //自动生成get set tostring...
@NoArgsConstructor //自动生成无参构造
@AllArgsConstructor//自动生成全参构造
@Accessors(chain = true)//开启链式编程
public class Car {
private String name;
private String color;
private Double price;
}
–5,创建CarController类
package cn.tedu.controller;
import cn.tedu.pojo.Car;
import cn.tedu.service.CarServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("car")
public class CarController {
@Autowired //想要调用service层的代码--di
private CarServiceImpl carService;
@RequestMapping("get")
public Object get(){
return carService.get(); //把结果给浏览器返回
}
}
–6,创建CarService接口
package cn.tedu.service;
import cn.tedu.pojo.Car;
//定义接口
public interface CarService {
//接口里的方法都是抽象方法,而且都是public的
Car get(); //获取汽车数据
// void add(Car c) ;//新增汽车数据
}
–7,创建CarServiceImpl实现类
package cn.tedu.service;
import cn.tedu.pojo.Car;
import org.springframework.stereotype.Component;
@Component
//实现了接口后,要重写抽象方法
public class CarServiceImpl implements CarService{
public Car get(){
Car c = new Car();
//lombok的链式编程
c.setName("保时捷").setColor("红色").setPrice(641000.0);
return c;
}
}
–8,测试
1, 启动服务器
2, 打开浏览器执行前端HTML网页,发起请求,请求服务器的数据,
3, 服务器收到请求后响应了准备好的数据
–9,总结
六
一,AOP
–1,概述
是一个面向切面编程的思想,补充了OOP的不足.
实现的效果: 对方法的增强,本质上就是在执行方法的前后添加功能.
经典的使用场景: 统计性能分析 / 权限管理 / 事务管理 / 日志 / 缓存…
好处: 让程序员更专注业务代码本身
切面: 本质上就是一个类
通知: 本质上就是一个方法,定义一些功能
分为:前置通知,后置通知和环绕通知,返回后通知,异常通知
前置通知 : 是方法执行前要执行的功能
后置通知 : 是方法执行后要执行的功能
环绕通知 : 是方法执行 前 后都要执行的功能
切点: 指定哪些类里的哪些方法要用 通知的功能
常用AOP注解:
@Aspect : 表示是一个切面类
@Before : 表示是一个前置通知
@After : 表示是一个后置通知
@Around : 表示是一个环绕通知
@PointCut : 表示切点
–2,步骤
1,添加jar包
org.springframework.boot
spring-boot-starter-aop
2,使用
package cn.tedu.service;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Service;
@Service //ioc
@Aspect//标记着这是一个aop的类:切面(由切点和组成)
public class AopAspect {
//1,切点(指定具体要用通知的类和方法)
//切点表达式:*是通配符 ..表示0~n个
//方法返回值/包路径/子包/类名/方法名/参数列表
@Pointcut("execution( * cn.tedu.service..*.*(..))")
public void point(){}
//2,通知(是一个方法自定义功能)
@Around("point()")//是一个环绕通知
public Object doAround(ProceedingJoinPoint joinPoint)
throws Throwable {
long time = System.currentTimeMillis();//计时开始
//去执行你的业务方法--joinPoint连接点
Object o = joinPoint.proceed();
time = System.currentTimeMillis()-time;//计时结束
String methodname = joinPoint.getTarget().getClass().getName()//获取类名
+"."+joinPoint.getSignature().getName();//获取方法名
System.out.println(methodname+"方法执行时间是: "+time);
return o ;
}
}
3,测试
启动服务器 , 访问指定包 里的资源时 , 就会自动触发切面中通知的功能.
二,Ajax
–1,概述
全称 异步的js and xml ,
好处: 异步访问 , 局部刷新
–2,步骤
导入vue.js和axios.js
编写HTML代码
语法:axios.get(url).then( a=>( a表示服务器返回的结果 ) )
测试 vue提供的ajax技术
123{{info}}
修改服务器的Controller代码
添加一个注解,@CrossOrigin //放行JS的请求–跨域的解决方案
测试
访问网页,网页会直接发起ajax请求,请求服务器的数据.服务器把数据返回交给ajax继续解析,最终实现局部刷新网页.
三，Mybatis
–1,概述
底层封装了JDBC , 对数据库可以进行操作 , 是一个优秀的持久层框架
好处: 简化了JDBC的开发步骤, 自动完成ORM映射
–2,核心资源
1,核心配置文件
mybatis-config.xml 配置了事务管理,数据源
2,映射文件
XxxMapper.xml 存放大量的CRUD的SQL语句
3,核心工具类
会话工厂SqlSessionFactory : 产生会话
会话SqlSession : 执行SQL语句
4,ORM
是指对象关系映射.
把表里的字段的值 查到 自动交给 类里的属性 保存
–3,入门案例
准备库,表,数据
修改pom.xml,添加mybatis的jar包
cgb2106boot03
cn.tedu
0.0.1-SNAPSHOT
4.0.0
day17
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.1.4
mysql
mysql-connector-java
5.1.48
创建核心配置文件mybatis-config.xml
创建映射文件UserMapper.xml,写SQL
封装pojo类
package cn.tedu.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
//注意:::属性的名 和 表里的字段名 必须一致,否则无法ORM
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class User {
private Integer id;
private String name;
private String addr;
private Integer age;
}七
一,Mybatis入门案例
–0,导入mybatis的jar包
cgb2106boot03
cn.tedu
0.0.1-SNAPSHOT
4.0.0
day17
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.1.4
mysql
mysql-connector-java
5.1.48
–1,核心配置文件
–2,映射文件
–3,创建User类
package cn.tedu.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
//注意:::属性的名 和 表里的字段名 必须一致,否则无法ORM
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class User {
private Integer id;
private String name;
private String addr;
private Integer age;
}
–4,测试类
package cn.tedu.test;
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.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
public class Test1 {
@Test
public void get() throws IOException {
InputStream in = Resources.getResourceAsStream(
"mybatis-config.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder()
.build(in);
SqlSession session = factory.openSession();
Object o = session.selectOne("userMapper.getById");
//User(id=1, name=hanmeimei, addr=北京, age=28)
System.out.println(o);
}
}
5，总结
二,Mybatis的练习
–1,修改映射文件UserMapper.xml
–2,修改测试类
package cn.tedu.test;
import cn.tedu.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.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class Test1 {
@Test
public void get() throws IOException {
//读取配置文件
InputStream in = Resources.getResourceAsStream(
"mybatis-config.xml");
//创建会话工厂
SqlSessionFactory factory = new SqlSessionFactoryBuilder()
.build(in);
//开启会话,准备执行SQL
SqlSession session = factory.openSession();
//定位SQL(namespace的值.id的值),并执行
//selectOne执行查询的SQL,并只会返回一个结果
Object o = session.selectOne("userMapper.getById",2);
//User(id=1, name=hanmeimei, addr=北京, age=28)
System.out.println(o);
//定位SQL(namespace的值.id的值),并执行
//selectList执行查询的SQL,并返回多个结果
List list = session.selectList("userMapper.getAll");
for(User u : list){
System.out.println(u);
}
//定位SQL(namespace的值.id的值),并执行,并给SQL传入参数
User u = session.selectOne(
"userMapper.getByName","xiongda");
System.out.println(u);
}
}
–3,总结
三,优化配置
–1,别名
修改核心配置文件,加别名的代码
修改映射文件,使用别名
四,接口开发
–1,概述
为了优化定位SQL的字符串拼接过程, namespace的值.id的值
步骤:
0, 创建接口 创建方法
1, namespace的值 是接口的全路径
2, id的值 是接口里的方法名
–2,使用
需求:查询id=1的部门信息
创建Dept类
package cn.tedu.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
//完成ORM,属性名 必须和字段名 一致
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class Dept {
private Integer id ;
private String dname ;
private String loc ;
}
创建DeptMapper.xml
修改核心配置文件,加了别名和引入Mapper
测试
package cn.tedu.test;
import cn.tedu.pojo.Dept;
import cn.tedu.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.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class Test1 {
@Test
public void get() throws IOException {
//读取配置文件
InputStream in = Resources.getResourceAsStream(
"mybatis-config.xml");
//创建会话工厂
SqlSessionFactory factory = new SqlSessionFactoryBuilder()
.build(in);
//开启会话,准备执行SQL
SqlSession session = factory.openSession();
//定位SQL(namespace的值.id的值),并执行
//selectOne执行查询的SQL,并只会返回一个结果
Object o = session.selectOne("userMapper.getById",2);
//User(id=1, name=hanmeimei, addr=北京, age=28)
System.out.println(o);
//定位SQL(namespace的值.id的值),并执行
//selectList执行查询的SQL,并返回多个结果
List list = session.selectList("userMapper.getAll");
for(User u : list){
System.out.println(u);
}
//定位SQL(namespace的值.id的值),并执行,并给SQL传入参数
User u = session.selectOne(
"userMapper.getByName","xiongda");
System.out.println(u);
//定位SQL(namespace的值.id的值)
Dept d = session.selectOne("deptMapper.getById");
System.out.println(d);
}
}
–3,改造
创建接口
package cn.tedu.dao;
import cn.tedu.pojo.Dept;
//接口的全路径=映射文件中namespace的值
//接口的方法名=映射文件中id的值
public interface DeptMapper {
Dept getById();
}
改造映射文件
改造测试类
package cn.tedu.test;
import cn.tedu.dao.DeptMapper;
import cn.tedu.pojo.Dept;
import cn.tedu.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.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class Test1 {
@Test
public void get() throws IOException {
//读取配置文件
InputStream in = Resources.getResourceAsStream(
"mybatis-config.xml");
//创建会话工厂
SqlSessionFactory factory = new SqlSessionFactoryBuilder()
.build(in);
//开启会话,准备执行SQL
SqlSession session = factory.openSession();
//定位SQL(namespace的值.id的值),并执行
//selectOne执行查询的SQL,并只会返回一个结果
Object o = session.selectOne("userMapper.getById",2);
//User(id=1, name=hanmeimei, addr=北京, age=28)
System.out.println(o);
//定位SQL(namespace的值.id的值),并执行
//selectList执行查询的SQL,并返回多个结果
List list = session.selectList("userMapper.getAll");
for(User u : list){
System.out.println(u);
}
//定位SQL(namespace的值.id的值),并执行,并给SQL传入参数
User u = session.selectOne(
"userMapper.getByName","xiongda");
System.out.println(u);
//定位SQL(namespace的值.id的值)
// Dept d = session.selectOne("deptMapper.getById");
// System.out.println(d);
//获取了指定的接口
DeptMapper mapper = session.getMapper(DeptMapper.class);
//调用接口里的方法
Dept dd = mapper.getById();
System.out.println(dd);
}
}
总结
五,练习接口开发
–1,修改 接口文件
package cn.tedu.dao;
import cn.tedu.pojo.Dept;
import java.util.List;
//接口的全路径=映射文件中namespace的值
//接口的方法名=映射文件中id的值
public interface DeptMapper {
Dept getById(); //根据id查
List getByName(String dname);//根据名字查
void save(Dept dept);//新增部门记录
}
–2,修改 映射文件
insert into dept values(#{id},#{dname},#{loc})
–3,修改 测试文件
package cn.tedu.test;
import cn.tedu.dao.DeptMapper;
import cn.tedu.pojo.Dept;
import cn.tedu.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.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class Test1 {
@Test
public void get() throws IOException {
//读取配置文件
InputStream in = Resources.getResourceAsStream(
"mybatis-config.xml");
//创建会话工厂
SqlSessionFactory factory = new SqlSessionFactoryBuilder()
.build(in);
//开启会话,准备执行SQL
SqlSession session = factory.openSession();
//定位SQL(namespace的值.id的值),并执行
//selectOne执行查询的SQL,并只会返回一个结果
Object o = session.selectOne("userMapper.getById",2);
//User(id=1, name=hanmeimei, addr=北京, age=28)
System.out.println(o);
//定位SQL(namespace的值.id的值),并执行
//selectList执行查询的SQL,并返回多个结果
List list = session.selectList("userMapper.getAll");
for(User u : list){
System.out.println(u);
}
//定位SQL(namespace的值.id的值),并执行,并给SQL传入参数
User u = session.selectOne(
"userMapper.getByName","xiongda");
System.out.println(u);
//定位SQL(namespace的值.id的值)
// Dept d = session.selectOne("deptMapper.getById");
// System.out.println(d);
//获取了指定的接口
DeptMapper mapper = session.getMapper(DeptMapper.class);
//调用接口里的方法
Dept dd = mapper.getById();
System.out.println(dd);
List ds = mapper.getByName("java教研部");
for (Dept d : ds) {
System.out.println(d);
}
Dept dept = new Dept();
dept.setId(100).setDname("ios开发部").setLoc("上海");
mapper.save(dept);
//mybatis不会自动提交事务,增删改需要自己提交事务
session.commit();
}
}
六,动态SQL
–1,概述
利用mybatis框架提供一些标签,完成SQL的拼接
常用标签 :
sql : 提取SQL片段
include : 引入指定的SQL片段
if : 用来判断,满足条件才拼接SQL
–2,修改映射文件,实现动态SQL
id,dname,loc
insert into dept values(#{id},#{dname},#{loc})
八
一,动态SQL
–1,foreach标签
修改映射文件
id,dname,loc
delete from dept where id in(
/*foreach用来完成遍历
collection表示要遍历哪种集合里的数据,值是固定值:array/list/Map.key
item表示即将遍历到的数据,separator是分隔符,#{ids}获取遍历到的数据
*/
#{ids}
)
insert into dept values(#{id},#{dname},#{loc})
修改接口文件
package cn.tedu.dao;
import cn.tedu.pojo.Dept;
import java.util.List;
//接口的全路径=映射文件中namespace的值
//接口的方法名=映射文件中id的值
public interface DeptMapper {
Dept getById(); //根据id查
List getByName(String dname);//根据名字查
void save(Dept dept);//新增部门记录
void delete(int[] a);//删除
}
修改测试类
package cn.tedu.test;
import cn.tedu.dao.DeptMapper;
import cn.tedu.pojo.Dept;
import cn.tedu.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.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class Test1 {
@Test
public void get() throws IOException {
//读取配置文件
InputStream in = Resources.getResourceAsStream(
"mybatis-config.xml");
//创建会话工厂
SqlSessionFactory factory = new SqlSessionFactoryBuilder()
.build(in);
//开启会话,准备执行SQL
SqlSession session = factory.openSession();
//定位SQL(namespace的值.id的值),并执行
//selectOne执行查询的SQL,并只会返回一个结果
Object o = session.selectOne("userMapper.getById",2);
//User(id=1, name=hanmeimei, addr=北京, age=28)
System.out.println(o);
//定位SQL(namespace的值.id的值),并执行
//selectList执行查询的SQL,并返回多个结果
List list = session.selectList("userMapper.getAll");
for(User u : list){
System.out.println(u);
}
//定位SQL(namespace的值.id的值),并执行,并给SQL传入参数
User u = session.selectOne(
"userMapper.getByName","xiongda");
System.out.println(u);
//定位SQL(namespace的值.id的值)
// Dept d = session.selectOne("deptMapper.getById");
// System.out.println(d);
//获取了指定的接口
DeptMapper mapper = session.getMapper(DeptMapper.class);
//调用接口里的方法
Dept dd = mapper.getById();
System.out.println(dd);
List ds = mapper.getByName(null);
for (Dept d : ds) {
System.out.println(d+"=================");
}
Dept dept = new Dept();
dept.setId(null).setDname("ios开发部").setLoc("上海");
mapper.save(dept);
//mybatis不会自动提交事务,增删改需要自己提交事务
session.commit();
mapper.delete(new int[]{103,104});
session.commit();
}
}
总结
二,ResultMap
–1,概述
resultType只能完成简单的ORM,只能完成那些 字段名 和 属性名一致的情况
字段名 和 属性名 不一样的情况,resultType必须换成resultMap,否则无法ORM
–2,测试
项目结构
创建了表,加了记录
CREATE TABLE `user_info` (
`id` int(11) NOT NULL auto_increment,
`user_name` varchar(20) default NULL,
`user_addr` varchar(20) default NULL,
`user_age` int(11) default NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
修改pom.xml,添加mybatis的jar包
cgb2106boot03
cn.tedu
0.0.1-SNAPSHOT
4.0.0
day19
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.1.4
mysql
mysql-connector-java
5.1.48
创建核心配置文件
创建映射文件
创建接口类
package cn.tedu.dao;
import cn.tedu.pojo.UserInfo;
import java.util.List;
public interface UserInfoMapper {
List selectList();//查询所有
}
创建pojo类
package cn.tedu.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class UserInfo {
private Integer id;
private String userName;
private String userAddr;
private Integer userAge;
}
测试
package cn.tedu.test;
import cn.tedu.dao.UserInfoMapper;
import cn.tedu.pojo.UserInfo;
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.jupiter.api.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class Test1 {
@Test
public void all() throws IOException {
InputStream in = Resources.getResourceAsStream(
"mybatis-config.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder()
.build(in);
//true表示自动提交事务
SqlSession session = factory.openSession(true);
//获取指定接口
UserInfoMapper mapper = session.getMapper(UserInfoMapper.class);
//调用方法
List list = mapper.selectList();
for (UserInfo uf : list) {
//UserInfo(id=1, userName=null, userAddr=null, userAge=null)
System.out.println(uf);
}
}
}
总结
3,优化简化resultmap
第一步：在核心配置文件中开启驼峰规则：
第二步：resultMap标签中添加新属性 autoMapping=“true”
三,SSM整合
–0,准备表和数据
CREATE TABLE `car` (
`id` int(11) NOT NULL auto_increment,
`name` varchar(10) default NULL,
`color` varchar(10) default NULL,
`price` double default NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
–0,添加mybatis的jar包
cgb2106boot03
cn.tedu
0.0.1-SNAPSHOT
4.0.0
SSM01
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.1.4
mysql
mysql-connector-java
5.1.48
runtime
–1,创建前端HTML网页
ssm
点我请求服务器的资源
–2,创建启动类RunApp
package cn.tedu;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
//扫描dao层接口文件所在的包,框架自动生成实现类
@MapperScan("cn.tedu.dao")
public class RunApp {
public static void main(String[] args) {
SpringApplication.run(RunApp.class);
}
}
–3,创建配置文件application.yml
#是一个特殊的文件,特殊在这个文件将被springboot框架自动加载-开箱即用
#格式非常严格,k: v
#SpringBoot配置mysql信息
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql:///mybatisdb?useUnicode=true&characterEncoding=utf8&useSSL=false
username: root
password: root
#SpringBoot整合Mybatis配置
mybatis:
#指定UserMapper.xml文件的位置
mapper-locations: classpath:*.xml
#开启驼峰映射
configuration:
map-underscore-to-camel-case: true
–4,创建pojo类
package cn.tedu.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import org.springframework.stereotype.Component;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)//lombok的链式编程
@Component //ioc
public class Car {
private Integer id;
private String name;
private String color;
private Double price;
}
–5,创建CarMapper接口
package cn.tedu.dao;
import cn.tedu.pojo.Car;
import java.util.List;
@Component//没有啥意义
public interface CarMapper {
List selectList(); //查询所有数据
}
–6,创建映射文件CarMapper.xml
–7,创建CarService接口
package cn.tedu.service;
import cn.tedu.pojo.Car;
import java.util.List;
public interface CarService {
List selectList(); //查询所有数据
}
–8,创建CarServiceImpl实现类
package cn.tedu.service;
import cn.tedu.dao.CarMapper;
import cn.tedu.pojo.Car;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service //ioc
public class CarServiceImpl implements CarService{
@Autowired //di依赖注解dao层,为了使用dao的功能
private CarMapper mapper;
@Override //查询所有数据
public List selectList() {
return mapper.selectList();
}
}
–9,创建CarController类
package cn.tedu.controller;
import cn.tedu.pojo.Car;
import cn.tedu.service.CarService;
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//相当于@Controller+@ResponseBody
@RequestMapping("car")
public class CarController {
@Autowired //di
private CarService carService ;
//查询所有数据
@RequestMapping("get")
public List selectList(){
return carService.selectList() ;
}
}
–10,测试
打开浏览器,访问服务器
–11,总结
