目录
3.在main目录下创建java和resources目录,修改web.xml版本为4.0
4.在resources目录下创建Spring配置文件application.xml,扫描使用了注解的根包
5.创建一个类,使用@Componet注解将其注入到Spring容器中
7.创建一个Servlet,访问该Servlet,获取Spring容器,从容器中获取注入的对象
2.创建包结构(controller、service、dao、entity),创建实体类
5.在WEB-INF目录下创建一个pages目录,在其中创建一个welcome.jsp页面
Object Relational Mapping 对象关系映射
一个半自动化的ORM框架。原本叫做ibatis,后来升级改名为MyBatis。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
在SpringMVC中,让某个控制层中的方法返回JSON格式的数据
2.自定义一个类,实现拦截器HandlerInterceptor接口
2.在pom.xml中添加mybatis集成SpringBoot依赖和数据库驱动
3.在springboot配置文件application.properties中
4.根据数据表创建实体类、dao层接口、service、controller
5.在SpringBoot的启动类上,加入@MapperScan注解,扫描dao层所在根包
框架
一套规范。
实际是他人实现的一系列接口和类的集合。通入导入对应框架的jar文件(maven项目导入对应的依赖),进行适当的配置,就能使用其中的所有内容。
开发者可以省去很多模板代码,如dao中的CRUD,MVC模式下层与层之间的关联。只需要集中精力实现项目中的业务逻辑部分。
Java主流框架
Spring、SpringMVC、MyBatis、MyBatisPlus、Hibernate、JPA等。
SSH:最初是Spring+Stucts2+Hibernate组成,之后Stucts2被SpringMVC取代。
SSM:Spring+SpringMVC+MyBatis
新项目使用SpringBoot,早起的SSH项目由于维护成本高,基本不会推翻重做,但会维护一些SSM项目。
无论是SSH还是SSM,Spring、SpringMVC必不可少。从2004年推出至今,依旧是主流框架中不可获取的一部分。
Spring
概念
一个轻量级开源的Java框架。是一个管理项目中对象的容器,同时也是其他框架的粘合器,目的就是对项目进行解耦。
轻量级:对原有代码的侵入很小。
Spring的核心是IOC控制反转和AOP面向切面编程
组成
名词解释
IOC
Inversion Of Control 控制反转
DI
Dependency Injection 依赖注入
举例说明
用代码描述场景:员工食堂每天提供事物
- 食物:米饭类
public class Rice{
public Rice(){
sout("今天吃米饭");
}
}
- 食物:面条类
public class Noodles{
public Noodles(){
sout("今天吃面条");
}
}
- 厨师类
public class Cook{
//定义一个做饭的方法,做什么饭new什么对象,创建食物对象的权限,是由当前厨师类决定。
public void cooking(){
//new Rice();
new Noodles();
}
}
- 员工:main方法
psvm(){
Cook cook = new Cook();
cook.cooking();
}
这种方式,Cook类中的cooking()方法创建什么对象,就输出什么内容。(厨师做什么,员工就吃什么)。
如果有人想要吃指定食物,就要修改源代码cooking()方法中创建的对象。
解决方案:定义一个接口:Food
public interface Food{
void info();
}
让原本的所有食物Rice类和Noodles类实现该接口
public class Rice implements Food{
@Override
public void info(){
sout("今天吃米饭");
}
}
public class Noodles implements Food{
@Override
public void info(){
sout("今天吃面条");
}
}
给厨师Cook类中cooking()方法定义一个参数:Food接口
public class Cook{
public void cooking(Food food){
food.info();
}
}
这时Cook对象调用cooking()方法时,需要提供一个Food接口类型的实现类。
psvm(){
Cook cook = new Cook();
//传递什么参数,旧调用该参数重写后的方法
cook.cooking(new Rice());
cook.cooking(new Noodles());
}
整个过程中,将创建什么食物对象的控制权,由厨师交给用户,这就是控制反转(IOC)。
厨师对象调用cooking()方法的参数,就是对于食物Food对象的依赖,是由用户注入进来的,这就是依赖注入(DI)。
这样一来,各个对象之间互相独立(没有在某个类中new另一个类的对象),降低了代码之间的耦合度。
总结:控制反转(IOC)是一种思想,就是让创建对象的控制权由自身交给第三方,控制反转这种思想,通过依赖注入(DI)的方式实现。
IOC和DI其实都是在描述控制反转,IOC是思想,DI是具体实现方式。
这里的第三方,就是Spring。Spring是一个容器,可以管理所有对象的创建和他们之间的依赖关系。
可以理解为:"Spring就是用来管理对象的,在需要用到某个对象的时候,帮我们自动创建"。
如Servlet+JSP模式写Web项目时,会在控制层Servlet中创建业务逻辑层Service对象,在Service层中创建数据访问层Dao对象。
有了Spring后,就不会出现new这些对象的代码了。
Spring需要导入对应的jar文件后,定义一个配置文件,在该配置文件中配置程序运行过程中所需的对象。
AOP
Aspect Orintend Programming 面向切面编程
Spring控制台应用
1.创建一个普通的Maven项目,不选择模板
2.添加Spring核心依赖
jdk8用5.x版本
<!-- spring-context表示spring核心容器 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.23</version>
</dependency>
3.创建一个Java类
package com.hqyj.spring01;
/*
* 定义一个普通的Java类
* PlainOrdinaryJavaObject pojo 相当于简化的javabean
* entity vo dto pojo 都是在描述实体类
* */
public class PlainOrdinaryJavaObject {
public void fun(){
System.out.println("一个PlainOrdinaryJavaObject(普通的Java类)对象");
}
}
4.创建Spring配置文件
创建一个Spring的配置文件,在其中注入上一步创建的类的对象
在resources目录下,创建一个xml文件,选择spring config,通常命名为application
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--bean标签表示,在Spring容器中,注入某个类的对象-->
<!--class属性表示要注入哪个类,写类的全限定名(包名+类名)-->
<!--id表示给类的对象的名称-->
<bean class="com.hqyj.spring01.PlainOrdinaryJavaObject" id="pojo"></bean>
</beans>
5.创建main方法所在类
解析Spring配置文件,获取注入的对象。
package com.hqyj.spring01;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
//创建一个自定义类的对象
//传统方式创建对象
//PlainOrdinaryJavaObject pojo = new PlainOrdinaryJavaObject();
//使用spring容器获取对象
//创建一个用于解析Spring配置文件的对象,参数为配置文件的名称。实际就是获取Spring容器
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
//获取容器中的对象
/*
只通过名称获取,返回值为Object类型,需要转换
Object obj = context.getBean("pojo");
PlainOrdinaryJavaObject pojo=(PlainOrdinaryJavaObject) obj;
*/
//使用这种方式,直接用指定类型接收
PlainOrdinaryJavaObject pojo = context.getBean("pojo", PlainOrdinaryJavaObject.class);
//能成功调用方法,说明Spring管理了该类的对象
pojo.fun();
//关闭Spring容器
context.close();
}
}
思考
- 1.对象在什么时候创建?
默认情况下,在解析Spring配置文件的时候,自动创建一个对象。
- 2.如果不想在解析时自动创建怎么办?
在配置文件的某个<bean>标签中,添加一个"lazy-init=true"属性,表示该对象设置为懒加载,
在初始化Spring容器时不会创建对象,只有在调用getBean()时才会创建对象
- 3.如果设置为懒加载,是不是每次调用getBean(),都会创建一个对象呢?
默认情况下,Spring容器只会创建一个对象。
在配置文件的某个<bean>标签中,添加一个"scope='prototype'"属性,表示每次调用getBean()方法,就会创建一个对象。
该属性的值默认为"singleton",表示单例模式,只会创建一个对象。
总结:默认情况下,通过<bean>标签定义的类,在Spring容器初始化时,创建一个对象。
bean标签常用属性
属性 | 作用 |
class | 定义类的全限定名 |
id | 定义对象的名称 |
lazy-init | 是否为懒加载。默认值为false,在解析配置文件时就会创建对象。设置为true表示懒加载,只有在getBean()时才会创建对象。 |
scope | 单例/原型模式。默认值为singleton,表示单例模式,只会创建一个对象。设置为prototype,表示原型模式,每调getBean()就创建一个对象。 |
init-method | 初始化时触发的方法。在创建完该对象时自动调用的方法。该方法只能是无参方法,该属性的值只需要写方法名即可 |
destory-method | 销毁时触发的方法。Spring容器关闭时自动调用的方法,该方法只能是无参方法。只有在单例模式下有效。 |
属性注入
给某个bean添加属性的方式有两种:构造器注入和setter注入
setter注入
这种方式注入属性时,类中必须要有set方法
在bean标签中,加入<property></property>标签,
该标签的name属性通常表示该对象的某个属性名,但实际是setXXX()方法中的XXX单词。
如有age属性,但get方法为getNianLing(),name属性就需要写成nianLing。
该标签的value属性表示给该类中的某个属性赋值,该属性的类型为原始类型或String。
该标签的ref属性表示给该类中除String以外的引用类型属性赋值,值为Spring容器中另一个bean的id。
<!--注入Car类对象并用set方式注入其属性-->
<bean class="com.hqyj.spring01.Car" id="c">
<!--该属性是字符串或原始类型,使用value赋值-->
<property name="brand" value="宝马"></property>
<!--name并不是类中是属性名,而是该属性对应的getXXX()方法中XXX的名称-->
<!--如Car类中有color属性,但get方法名为getColo(),这里就要写为colo-->
<property name="colo" value="白色"></property>
</bean>
<!--注入Person类对象并用set方式注入其属性-->
<bean class="com.hqyj.spring01.Person" id="p1">
<property name="name" value="王海"></property>
<property name="age" value="22"></property>
<!--属性是引用类型,需要通过ref赋值,值为另外的bean的id ref即references-->
<property name="car" ref="c"></property>
</bean>
构造方法注入
这种方式注入属性时,类中必须要有相应的构造方法
在bean标签中,加入<constructor-arg></constructor-arg>标签,
该标签的name属性表示构造方法的参数名,index属性表示构造方法的参数索引。
赋值时,原始类型和字符串用value,引用类型用ref。
<!--注入Person类对象并用构造方法注入其属性-->
<bean class="com.hqyj.spring01.Person" id="p2">
<!--constructor-arg表示构造方法参数 name是参数名 index是参数索引-->
<constructor-arg name="name" value="张明"></constructor-arg>
<constructor-arg index="1" value="20"></constructor-arg>
<constructor-arg name="car" ref="c"></constructor-arg>
</bean>
复杂属性注入
/*
* 定义电影类
* */
public class Movie {
//电影名
private String movieName;
//导演
private String director;
//时长
private int duration;
//主演
private List<String> playerList;
//类型
private String movieType;
//放映时间,最终格式为yyyy/MM/dd HH:mm:ss
private String showTime;
}
List类型的属性
<!--注入Movie对象-->
<bean class="com.hqyj.spring01.Movie" id="movie1">
<property name="movieName" value="夏洛特烦恼"></property>
<property name="director" value="闫非、彭大魔"></property>
<property name="duration" value="87"></property>
<!--List类型属性赋值-->
<property name="playerList" >
<!--使用list标签-->
<list>
<!--如果集合中保存的是引用类型,使用ref标签-->
<!--如果集合中保存的是原始类型或字符串,使用value标签-->
<value>沈腾</value>
<value>艾伦</value>
<value>马丽</value>
</list>
</property>
<property name="movieType" value="喜剧"></property>
<property name="showTime" value="2010/06/01 0:0:0"></property>
</bean>
Set类型的属性
<!--注入PetShop对象-->
<bean class="com.hqyj.spring01.test3.PetShop" id="petShop">
<property name="shopName" value="xxx宠物店"></property>
<property name="petSet">
<!--Set类型的属性-->
<set>
<!--如果中保存的是原始类型或字符串,使用value子标签-->
<!--如果保存的是引用类型,使用ref子标签加bean属性设置对应的id-->
<ref bean="p1"></ref>
<ref bean="p2"></ref>
<ref bean="p3"></ref>
</set>
</property>
</bean>
Map类型的属性
<!--注入Cinema对象-->
<bean class="com.hqyj.spring01.Cinema" id="cinema">
<property name="name" value="万达影城"></property>
<property name="timeTable">
<!--Map类型属性赋值,标明键和值的类型-->
<map key-type="java.lang.Integer" value-type="com.hqyj.spring01.Movie">
<!--entry标签表示键值对 如果键值对都是原始类型或字符串,使用key和value-->
<!--如果键值对中有引用类型,使用key-ref或value-ref-->
<entry key="1" value-ref="movie1"></entry>
<entry key="2" value-ref="movie2"></entry>
</map>
</property>
</bean>
属性值如果通过某个方法调用而来
如使用String保存yyyy/MM/dd格式的日期,需要通过SimpleDateFormat对象调用parse()方法而来
<!--
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
-->
<!--注入SimpleDateFormat对象,设置日期格式-->
<bean class="java.text.SimpleDateFormat" id="sdf">
<!--如果构造方法注入时,该构造方法只有一个参数,可以不用写name或index-->
<constructor-arg value="yyyy/MM/dd"></constructor-arg>
</bean>
<!--
Date now = new Date();
-->
<!--注入Date对象-->
<bean class="java.util.Date" id="now"></bean>
<!--注入Pet对象-->
<bean class="com.hqyj.spring01.test3.Pet" id="p1">
<property name="petType" value="哈士奇"></property>
<property name="petNickName" value="小哈"></property>
<!--使用当前时间作为该属性的值,以yyyy/MM/dd-->
<!--
sdf.format(now);
-->
<property name="petBirthday">
<!--如果某个值是通过某个bean调用了某个方法而来-->
<bean factory-bean="sdf" factory-method="format">
<!--方法的实际参数-->
<constructor-arg ref="now"></constructor-arg>
</bean>
</property>
</bean>
属性自动注入autowire
以上所有案例中,如果要在A对象中注入一个引用类型的对象B,都是手动将对象B注入到对象A中。
如在Person中注入Car对象,在Cinema中注入Movie等。
这种情况下,如果当某个被注入的bean的id更改后,所有引用了该bean的地方都要进行修改。
所以将手动注入更改为自动注入(自动装配),就无需添加相应的<property>标签,甚至可以无需定义bean的id。
实现自动注入
在某个bean标签中,加入autowire属性,设置值为"byName"或"byType"。通常设置为"byType"。
Car类
package com.hqyj.spring01.test1;
import java.util.HashMap;
public class Car {
private String brand;
private String color;
@Override
public String toString() {
return "Car{" +
"brand='" + brand + '\'' +
", color='" + color + '\'' +
'}';
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
Person类
package com.hqyj.spring01.test1;
public class Person {
private String name;
private int age;
private Car car;
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", car=" + car +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Car getCar() {
return car;
}
//自动注入时,必须要有该方法
//byType方式自动注入,会自动在容器中寻找该方法参数类型
//byName方式自动注入,会自动在容器中寻找该方法setCar中的car这个id
public void setCar(Car car) {
this.car = car;
}
}
配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--在容器中注入Car类型的bean-->
<bean class="com.hqyj.spring01.test1.Car" id="car">
<property name="brand" value="宝马"></property>
<property name="colo" value="白色"></property>
</bean>
<!--注入Person类的bean-->
<!--autowire="byType"表示自动检测该类中是否需要使用引用类型参数,如果容器中正好有唯一的一个对应类型的bean,就会自动赋值给对应的属性-->
<bean class="com.hqyj.spring01.test1.Person" id="person" autowire="byType">
<property name="name" value="赵明"></property>
<property name="age" value="26"></property>
</bean>
<!--autowire="byName"表示自动检测该类中的setXXX方法,如果某个setXXX方法的XXX和容器某个对象的id对应,就会自动赋值给对应的属性-->
<bean class="com.hqyj.spring01.test1.Person" id="person2" autowire="byName">
<property name="name" value="王海"></property>
<property name="age" value="26"></property>
</bean>
</beans>
Main
package com.hqyj.spring01.test1;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
Person person = context.getBean("person", Person.class);
//此时打印时,会输出姓名、年龄和Car对象
System.out.println(person);
context.close();
}
}
autowire属性的值
- byType
- 类中要有被注入的属性的setter()方法
- 被自动注入的对象可以没有id
- Spring容器中,某个对象的类型要与该setter()方法的参数类型一致,且容器中只有一个该类型的对象。
- 如setCar(Car c),Spring就会自动在容器中寻找类型为Car的对象自动装配
- byName
- 类中要有被注入的属性的setter()方法
- 被自动注入的对象必须要有id
- 实际是根据setXXX()方法set后的单词XXX关联
- 如setCar(Car c),Spring就会自动在容器中寻找id为car的对象自动装配
在Web项目中,可以利用自动装配,在控制层中自动装配业务逻辑层的对象,在业务逻辑层中自动装配数据访问层的对象。
属性自动注入练习
在电影院案例的基础上
1.创建一个dao层CinemaDao类,包含Cinema对象,定义一个fun()方法,输出Cinema对象
package com.hqyj.spring01.test2.dao;
import com.hqyj.spring01.test2.Cinema;
/*
* 定义数据访问层
* 模拟查询数据库得到结果
* */
public class CinemaDao {
private Cinema cinema;
public void setCinema(Cinema cinema) {
this.cinema = cinema;
}
public void fun(){
System.out.println(cinema);
}
}
2.创建一个controller层CinemaController类,包含CinemaDao对象,定义方法fun()调用CinemaDao中的fun()方法
package com.hqyj.spring01.test2.controller;
import com.hqyj.spring01.test2.dao.CinemaDao;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/*
* 定义控制层类,该层需要使用下一层dao中的方法
* */
public class CinemaController {
//这里无需创建对象,让Spring自动注入CinemaDao对象
private CinemaDao cinemaDao;
public void setCinemaDao(CinemaDao dao) {
this.cinemaDao = dao;
}
public void fun(){
cinemaDao.fun();
}
}
最终在Main方法中获取Controller对象后,调用fun()
public static void main(String[] args) {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("movie.xml");
CinemaController controller = context.getBean("controller", CinemaController.class);
controller.fun();
}
配置文件
<!--省略movie对象-->
<!--注入Cinema对象-->
<bean class="com.hqyj.spring01.test2.Cinema" id="cinema">
<property name="name" value="万达影城"></property>
<property name="timeTable">
<!--Map类型属性赋值,标明键和值的类型-->
<map key-type="java.lang.Integer" value-type="com.hqyj.spring01.test2.Movie">
<!--entry标签表示键值对 如果键值对都是原始类型或字符串,使用key和value-->
<!--如果键值对中有引用类型,使用key-ref或value-ref-->
<entry key="1" value-ref="movie1"></entry>
<entry key="2" value-ref="movie2"></entry>
</map>
</property>
</bean>
<!--该类中有一个Cinema类型的属性,这里使用了autowire=byType自动装配,会在容器中寻找Cinema类型的对象自动赋值给属性-->
<bean class="com.hqyj.spring01.test2.dao.CinemaDao" autowire="byType"></bean>
<!--该类中有一个CinemaDao类型的属性,这里使用了autowire=byType自动装配,会在容器中寻找CinemaDao类型的对象自动赋值给属性-->
<bean class="com.hqyj.spring01.test2.controller.CinemaController" id="controller" autowire="byType"></bean>
day2
在作业练习中,controller、dao都需要setter方法,再在spring配置文件中配置autowire后,才能实现自动装配。
如果使用了注解,就无需在类中添加setter方法,spring配置文件中也无需设置autowire。
Spring核心注解
在Spring配置文件中加入
<!--设置要扫描的包,扫描这个包下所有使用了注解的类-->
<context:component-scan base-package="com.hqyj.spring02.bookSystem"></context:component-scan>
类上加的注解
- @Component
- 当一个类不好归纳时,定义为普通组件
- @Controller
- 定义一个类为控制层组件
- @Service
- 定义一个类为业务层组件
- @Repository
- 定义一个类为持久层(数组访问层)组件
- @Lazy/@Lazy(value=true)
- 设置该类为懒加载。
- @Scope(value="singleton/prototype")
- 设置为单例/原型模式。
说明
以上注解公共特点
- 都是将对应类的对象注入到Spring容器中,用于替换配置文件中的bean标签
- 都默认是单例模式非懒加载
- 默认注入的对象id为当前类的类名首字母小写形式
- 如在BookDao类上添加,id默认为bookDao
- 可以通过注解的value属性自定义注入的对象的id名,如@Component(value="key")表示注入的对象id为key
属性上加的注解
- @Autowired
- 优先使用byType方式从Spring容器中获取对应类型的对象自动装配。先检索Spring容器中对应类型对象的数量,如果数量为0直接报错;数量为1直接装配
数量大于1,会再尝试使用byName方式获取对应id的对象,但要配合@Qualifier(value="某个对象的id")一起使用,指定id进行装配
- @Qualifier(value="某个对象的id")
- 配合@Autowired注解,使用byName方式获取某个对象id的bean进行装配
- @Resource(name="某个对象的id")
- 该注解相当于@Autowired+@Qualifier(value="某个对象的id")
- 优先使用byName方式,从Spring容器中检索name为指定名的对象进行装配,如果没有则尝试使用byType方式,要求对象有且只有一个,否则也会报错。
说明
- 如果要在某个类中使用Spring容器中的某个对象时,只需定义成员变量,无需创建对象,通过@Autowired或@Resource注解进行自动装配
- 实际开发中,绝大部分情况下,需要自动装配对象有且只有一个,并且命名规范,所以@Autowired或@Resource区别不是很大。@Autowired优先使用byType方式,@Resource优先使用byName方式
- 如果@Resource不能使用,是因为缺少javax.annotation包,需要引入对应依赖
<dependency>
<groupId>javax.annotation</groupId>
<artifactId>javax.annotation-api</artifactId>
<version>1.3.2</version>
</dependency>
在Web项目中使用Spring
1.创建基于Maven的web-app项目
2.添加依赖
<!--servlet-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<!--spring容器-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.23</version>
</dependency>
<!--web集成spring-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.23</version>
</dependency>
3.在main目录下创建java和resources目录,修改web.xml版本为4.0
4.在resources目录下创建Spring配置文件application.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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--扫描使用了Spring注解的根包-->
<context:component-scan base-package="com.hqyj.springweb"></context:component-scan>
</beans>
5.创建一个类,使用@Componet注解将其注入到Spring容器中
package com.hqyj.springweb.entity;
import org.springframework.stereotype.Component;
@Component
public class Pojo {
public void fun(){
System.out.println("hello springweb!");
}
}
如何初始化Spring容器(解析Spring配置文件)
在控制台应用程序中,可以在main方法中通过ClassPathXmlApplicationContext来解析Spring配置文件,初始化Spring容器。
在web项目中没有main方法,只有servlet中的service方法,如果在service方法中创建ClassPathXmlApplicationContext对象,会每次访问都执行。
而Spring容器只需初始化一次,在项目启动时就解析Spring配置文件,全局监听器就是一个很好的选择。
spring-web包中提供了一个ContextLoaderListener类,它实现了ServletContextListener,属于项目级别的全局监听器。
这个类需要一个contextConfigLocation参数,表示要解析的Spring配置文件的路径。
这个监听器会在项目启动时,读取指定的Spring配置文件路径,并且创建WebApplicationContext对象,即Spring容器。
6.在web.xml中配置监听器用于初始化Spring容器
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--配置监听器ContextLoaderListener-->
<listener>
<!--监听器全限定名-->
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--定义全局参数contextConfigLocation用于读取Spring配置文件-->
<context-param>
<!--参数名固定contextConfigLocation-->
<param-name>contextConfigLocation</param-name>
<!--只是Spring配置文件的路径 classpath:表示从根目录出发-->
<param-value>classpath:application.xml</param-value>
</context-param>
</web-app>
7.创建一个Servlet,访问该Servlet,获取Spring容器,从容器中获取注入的对象
package com.hqyj.springweb.controller;
import com.hqyj.springweb.entity.Pojo;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/hello")
public class MyServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//获取Spring容器
WebApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
//从容器中获取某个bean
Pojo pojo = app.getBean("pojo", Pojo.class);
pojo.fun();
}
}
在Spring-web项目中使用Spring-jdbc
Spring提供了一套自己的JDBC解决方案,相较于自己写的JDBC,省去了繁琐的过程(获取连接、关闭),简化了对数据库的操作。
Spring-jdbc后续会用其他持久层框架代替,如MyBatis、JPA。
1.引入相关依赖
当前案例中核心的依赖是 spring-jdbc
<!--servlet-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.31</version>
</dependency>
<!--jstl-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!--spring容器-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.23</version>
</dependency>
<!--web集成spring-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.23</version>
</dependency>
<!-- spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.23</version>
</dependency>
2.创建包结构(controller、service、dao、entity),创建实体类
public class Hero {
private int id;
private String name;
private String position;
private String sex;
private int price;
private String shelfDate;
//省略get/set、构造方法、toString等
}
3.在Spring配置文件中配置数据源和JDBC模板
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--扫描使用了Spring注解的根包-->
<context:component-scan base-package="com.hqyj.springweb"></context:component-scan>
<!--配置数据源-->
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
<!--配置MySQL驱动-->
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
<!--配置MySQL地址-->
<property name="url" value="jdbc:mysql://localhost:3306/gamedb?serverTimezone=Asia/Shanghai"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!--配置JDBC模板-->
<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
<!--设置要操作的数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>
4.数据访问层(dao)的写法
package com.hqyj.springweb.dao;
import com.hqyj.springweb.entity.Hero;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public class HeroDao {
@Autowired
//通过jdbc模板对象实现CRUD
private JdbcTemplate jdbcTemplate;
/*
* 查询所有
* */
public List<Hero> queryAll() {
//定义sql语句
String sql = "select * from hero";
//BeanPropertyRowMapper对象表示将查询到的字段与指定的类中的属性进行映射
BeanPropertyRowMapper<Hero> mapper = new BeanPropertyRowMapper<>(Hero.class);
//query()方法执行查询
List<Hero> list = jdbcTemplate.query(sql, mapper);
return list;
}
/*
* 删除
* */
public boolean delete(int id) {
String sql = "delete from hero where id=?";
int i = jdbcTemplate.update(sql, id);
return i > 0;
}
/*
* 修改
* */
public boolean update(Hero hero) {
String sql = "update hero set name=?,sex=?,position=?,price=?,shelf_date=? where id=?";
int i = jdbcTemplate.update(sql, hero.getName(), hero.getSex(), hero.getPosition(), hero.getPrice(), hero.getShelfDate(), hero.getId());
return i > 0;
}
/*
* 添加
* */
public boolean insert(Hero hero) {
String sql = "insert into hero values(null,?,?,?,?,?)";
int i = jdbcTemplate.update(sql, hero.getName(), hero.getSex(), hero.getPosition(), hero.getPrice(), hero.getShelfDate());
return i > 0;
}
/*
* 根据id查询
* */
public Hero findById(int id) {
String sql = "select * from hero where id=?";
BeanPropertyRowMapper<Hero> mapper = new BeanPropertyRowMapper<>(Hero.class);
Hero hero = jdbcTemplate.queryForObject(sql, mapper, id);
return hero;
}
}
忽略后续service、servlet、jsp等;
JDBCTemplate常用方法
方法 | 作用 | 说明 |
query(String sql,RowMapper mapper) | 无条件查询 | 返回值为List集合 |
update(String sql) | 无条件更新(删除、修改) | 返回值为受影响的行数 |
query(String sql,RowMapper mapper,Object... objs) | 条件查询 | 可变参数为?的值 |
update(String sql,Object... objs) | 条件更新(增加、删除、修改) | 可变参数为?的值 |
queryForObject(String sql,RowMapper mapper) | 无条件查询单个对象 | 返回值为指定对象 |
queryForObject(String sql,RowMapper mapper,Object... objs) | 条件查询单个对象 | 返回值为指定对象 |
execute(String sql) | 执行指定的sql | 无返回值 |
AOP
概念
Process Oriented Programming 面向过程编程POP
Object Oriented Programming 面向对象编程OOP
Aspect Oriented Programming 面向切面编程AOP
以上都是编程思想,但AOP不是OOP和POP的替代,而是增强、拓展和延伸。主流编程思想依然是OOP。
作用
在传统的OOP思想中,我们将程序分解为不同层次的对象,通过封装、继承、多态等特性,
将对象组织成一个整体来完成功能。但在某些场景下,OOP会暴露出一些问题。
如在处理业务中,除了核心的业务代码外,通常还会添加一些如果参数验证、异常处理、事务、记录日志等操作。
这些内容会分散在各个业务逻辑中,依旧会出现大量重复操作。如果将这些重复的代码提取出来,在程序编译运行时,
再将提出来的内容应用到需要执行的地方,就可以减少很多代码量。方便统一管理,更专注于核心业务。
简单来说,就是将不同位置中重复出现的一些事情拦截到一处进行统一处理。
如图,这是用户模块的不同操作,其中除了核心业务之外,其余都是重复代码
将相同的位置进行切分
切分后
使用
一个普通业务层service类
package com.hqyj.springweb.service;
import com.hqyj.springweb.dao.HeroDao;
import com.hqyj.springweb.entity.Hero;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/*
* 一个普通业务层service类
* */
@Service
public class HeroService {
@Autowired
private HeroDao dao;
public List<Hero> queryAll() {
//在没有使用AOP时,比如要在执行前记录日志
//System.out.println("============");
//System.out.println("操作开始执行"+new Date());
System.out.println("xxx进行了查询操作");
//核心业务代码
List<Hero> list=dao.queryAll();
//在没有使用AOP时,比如要在执行后记录日志
//System.out.println("操作执行结束"+new Date());
//System.out.println("============");
return list;
}
public void delete(int id) {
//在没有使用AOP时,比如要在执行前记录日志
//System.out.println("============");
//System.out.println("操作开始执行"+new Date());
System.out.println("xxx删除了"+id);
//核心业务代码
dao.delete(id);
//在没有使用AOP时,比如要在执行后记录日志
//System.out.println("操作执行结束"+new Date());
//System.out.println("============");
}
}
在项目中添加AOP所需依赖
<!-- 切面织入包 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.19</version>
<scope>runtime</scope>
</dependency>
在Spring配置文件中配置AOP
<!--配置AOP-->
<aop:config>
<!--配置切面(配置拦截后要做的事情)-->
<!--ref是提取出的公共代码所在类LogOperate在Spring容器中的id。由于使用了@Componet注解,默认id名为类名首字母小写-->
<aop:aspect ref="logOperate">
<!--配置切点(对哪个包中的哪个类、哪个方法执行的时候进行拦截)-->
<!--id是切点名,自定义-->
<aop:pointcut id="logPointcut" expression="execution(* com.hqyj.springweb.service..*.*(..))"/>
<!--配置前置增强(切点之前执行的方法)-->
<aop:before method="start" pointcut-ref="logPointcut"></aop:before>
<!--配置后置增强(切点之后执行的方法)-->
<aop:after method="end" pointcut-ref="logPointcut"></aop:after>
</aop:aspect>
</aop:config>
MVC
是将一个应用分为三个组成部分:Model模型,View视图,Controller控制器
这样会降低系统的耦合度,提高它的可扩展性和维护性。
SpringMVC
在Web阶段中,控制层是由Servlet实现,传统的Servlet,需要创建、重写方法、配置映射。使用时极不方便,SpringMVC可以替换Servlet。
SpringMVC是Spring框架中位于Web开发中的一个模块,是Spring基于MVC设计模式设计的轻量级Web框架。
SpringMVC提供了一个DispatcherServlet的类,是一个Servlet。它在指定映射(通常设置为/或*.do)接收某个请求后,调用相应的模型处理得到结果,再通过视图解析器,跳转到指定页面,将结果进行渲染。
原理大致为:配置SpringMVC中的DispatcherServlet,将其映射设置为/或*.do。
如果是/表示一切请求先经过它,如果是*.do表示以.do结尾的请求先经过它,
它对该请求进行解析,指定某个Controller中的某个方法,这些方法通常返回一个字符串,
这个字符串是一个页面的名称,再通过视图解析器,将该字符串解析为某个视图的名称,跳转到该视图页面。
详细流程
使用SpringMVC
1.创建webapp项目
- 修改web.xml版本为4.0
- 创建java和resources目录
- 创建包结构
2.添加依赖
<!-- spring-webmvc -->
<!-- 这个依赖会包含spring-web和spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.23</version>
</dependency>
3.配置初始化Spring
- 在resources目录下创建Spring配置文件application.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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--设置扫描使用了注解的根包-->
<context:component-scan base-package="com.hqyj.springmvc"></context:component-scan>
</beans>
- 在web.xml中使用监听器ContextLoaderListener初始化Spring
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--配置全局监听器初始化Spring-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--定义全局参数读取Spring配置文件-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:application.xml</param-value>
</context-param>
</web-app>
4.配置SpringMVC
- 在resources目录下创建配置SpringMVC的配置文件springmvc.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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--扫描控制层所在的包-->
<context:component-scan base-package="com.hqyj.springmvc.controller"></context:component-scan>
<!--配置内部资源视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--最终控制层跳转的页面所在的路径及页面自身后缀名-->
<!--jsp页面不建议直接通过浏览器访问。在WEB-INF目录下在资源,无法通过浏览器直接方法,所以将jsp保存在WEB-INF目录下,最好创建一个pages-->
<property name="prefix" value="/WEB-INF/pages/"></property>
<!--现阶段使用jsp输出数据,所以后缀为.jsp-->
<property name="suffix" value=".jsp"></property>
</bean>
```
- 在web.xml中配置DispatcherServlet
- 将该Servlet的请求映射设置为/,表示所有请求都会访问该Servlet,由该Servlet再进行分发
<!--配置DispatcherServlet-->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--设置该Servlet的初始化参数,用于读取SpringMVC配置文件-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<!--设置该servlet的映射为/或*.do-->
<url-pattern>/</url-pattern>
</servlet-mapping>
5.在WEB-INF目录下创建一个pages目录,在其中创建一个welcome.jsp页面
- 通常jsp页面不允许被浏览器直接访问,需要保存在WEB-INF目录下
6.编写控制层代码
- 在controller包下创建一个类,加上@Controller注解
- 该类中定义的方法方法加入@RequestMapping()注解表示访问该方法的映射
- 该类中定义的方法返回值通常为字符串,表示某个页面的名称,也可以是另一个controller中的方法映射名
package com.hqyj.springmvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
//加入@Controller注解表示该类是一个控制层类,替换之前的servlet
@Controller
//该注解如果只设置请求映射,直接填字符串
@RequestMapping("/first")
public class HelloController {
//该注解如果还有其他参数要设置,路径用path赋值
@RequestMapping(path="/hello")
public String hello(){
//返回的字符串是某个页面的名称或另一个控制层中方法的请求映射
return "welcome";
}
}
将项目部署到tomcat后,访问http://localhost:8080/SpringMVC_war_exploded/first/hello,即可跳转到指定页面
SpringMVC相关注解
- @Controller
- 只能写在类上,表示该类属于一个控制器
- @RequestMapping("/请求映射名")/@RequestMapping(value="/请求映射名")/@RequestMapping(path="/请求映射名")
- 该注解可以写在类或方法上。写在类上用于区分功能模块,写在类上用于区分具体功能
- 默认写一个属性或value或path后的值,都表示访问该类或该方法时的请求映射
- @RequestMapping(value="/请求映射名",method=RequestMethod.GET/POST/PUT/DELETE)
- method属性表示使用哪种请求方式访问该类或该方法
- 如果注解中不止一个属性,每个属性都需要指定属性名
- **@GetMapping("/请求映射名")**相当于@RequestMapping(value="/请求映射名",method=RequestMethod.GET)
- post、put、delete同理
- @GetMapping只能写在方法上
- @PathVariable
- 该注解写在某个方法的某个形参上
- 通常配合@RequestMapping("/{path}")获取请求时传递的参数
@RequestMapping("/{path}")
public String fun(@PathVariable("path") String pageName){
return pageName;
}
//当前方法如果通过"localhost:8080/项目名/hello"访问,就会跳转到hello.jsp
//当前方法如果通过"localhost:8080/项目名/error"访问,就会跳转到error.jsp
//映射中的/{path}就是获取路径中的hello或error,将其赋值给形参
//通常用于跳转指定页面
- @RequestParam(value="传递的参数名",defaultValue ="没有传递参数时的默认值")
- 该注解写在某个方法的某个参数上
- 用于获取提交的数据,可以设置默认值在没有提交数据时使用
控制层中获取请求时传递的参数
- controller中方法的形参名和表单的name或?后的参数名一致
表单或a标签
<form action="${pageContext.request.contextPath}/first/sub">
<input type="text" name="username">
<input type="text" name="password">
<input type="submit" >
</form>
<a href="${pageContext.request.contextPath}/first/sub?username=admin">xxx</a>
controller
public String login(String username,int password){
//此时可以正常获取
//无关数据类型,但是提交数据时必须是对应的类型,否则会有400错误
}
- controller中方法的形参名和表单的name或?后的参数名不一致
controller
public String login(@RequestParam(value="username",defaultValue="admin")String name,@RequestParam("username")int pwd){
//如果没有提交数据时,会使用设置的默认值
}
- 如果传递的参数都是某个实体类中的属性时
User类
package com.hqyj.springmvc.entity;
public class User {
private String username;
private String password;
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
'}';
}
public User() {
}
public User(String username, String password) {
this.username = username;
this.password = password;
}
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;
}
}
controller
@RequestMapping("/login")
public String login(User user){
//某个实体类的属性和提交的参数名一致时,可以直接将对象作为形参,会自动将对应参数赋值给对应属性
System.out.println(user);
return "";
}
解决提交数据时的中文乱码
使用过滤器解决中文乱码。
在web.xml中配置spring-web提供的CharaterEncodingFilter过滤器
<!--定义解决中文乱码的过滤器CharacterEncodingFilter-->
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<!--设置编码格式-->
<init-param>
<!--该过滤器需要设置一个encoding属性,用于设置编码格式-->
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<!--设置将什么请求经过该过滤器,通常设置为/*表示一切请求先经过该过滤器-->
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
将数据保存到作用域中
- 在controller中的某个方法的参数列表里添加Model参数
- 调用Model对象的addAttribute(String str,Object obj)方法,将某个obj对象保存在request作用域中,命名为str
@RequestMapping("/queryAll")
public String queryAll(Model model){
ArrayList list = new ArrayList<>();
list.add("qwe");
list.add(123);
list.add(true);
list.add("哈哈");
//将list保存到request作用域中
model.addAttribute("list",list);
//这种跳转属于请求转发
return "welcome";
}
- 在controller中的某个方法的参数列表里添加ModelAndView参数,同时将该方法的返回值设置为ModelAndView类型
- 使用ModelAndView对象调用addObject(String str,Object obj),将某个obj对象保存在request作用域中,命名为str
- 使用ModelAndView对象调用setViewName(String viewName),跳转到viewName页面
package com.hqyj.springmvc.controller;
import com.hqyj.springmvc.service.HeroService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;
import org.springframework.web.servlet.ModelAndView;
@Controller @RequestMapping("/hero") //如果要将数据保存到session中,使用该注解定义session中对象的名称 @SessionAttributes({"str1","str2"}) public class HeroController { @Autowired private HeroService heroService;
@RequestMapping("/queryAll")
public String queryAll(Model model){
model.addAttribute("list", heroService.queryAll());
return "heroList";
}
@RequestMapping("/showAll")
public ModelAndView queryAll(ModelAndView mav){
//默认保存查询出的对象到request中,命名为list
mav.addObject("list",heroService.queryAll());
//也可以保存到session
//mav.addObject("str1",heroService.queryAll());
//设置要跳转的页面
mav.setViewName("heroList");
return mav;
}
}
**数据都是保存在request作用域中**,在页面中使用jsp内置对象或EL获取。
如果要保存到session中,需要在类上加入@SessionAttributes({"str1","str2"})注解,str1,str2表示保存到session中的对象的名称,再在方法中,使用
Model对象的addAttribute(String str,Object obj)将其保存在session中。
# SpringMVC中的跳转
- 控制层跳转到某个jsp页面
- 在控制层中定义方法,这种方式跳转,属于请求转发
- 如果要使用重定向跳转,在页面名之前添加"redirect:"
```java
@RequestMapping("/hello")
public String hello(){
//返回页面名称
return "hello";//请求转发
}
@RequestMapping("/hello")
public ModelAndView hello(ModelAndView mav){
//设置页面名称
mav.setViewName("hello");
return mav;
}
```
- 在springmvc配置文件中
```xml
<mvc:view-controller path="请求映射" view-name="页面名称"></mvc:view-controller>
<!-- 访问项目根目录,跳转到welcome.jsp页面 -->
<mvc:view-controller path="/" view-name="welcome"></mvc:view-controller>
<!-- 这个标签使用时,会让@RequesMapping失效,如果要共存,添加以下标签 -->
<!--来自于xmlns:mvc="http://www.springframework.org/schema/mvc" -->
<mvc:annotation-driven></mvc:annotation-driven>
```
- 控制层跳转到另一个控制层中的方法
- 方法的返回值为"**redirect/forward:另一个控制层中方法的映射名**"
```java
@RequestMapping("/hello")
public String hello(){
return "redirect:hero";//使用重定向的方式,跳转到映射名为hero的控制层
return "forward:hero"//使用请求转发的方式,跳转到映射名为hero的控制层
}
```
- jsp页面跳转另一个jsp页面
- 当前项目中jsp页面都在WEB-INF下,无法直接访问,a标签同样如此,只能通过控制层跳转页面
- 定义用于跳转页面控制层类
```java
package com.hqyj.springmvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
/*
* 定义一个用于跳转指定页面或controller的控制层
* */
@Controller
public class ToPageController {
/*
项目启动时或直接访问根目录,跳转到指定的controller
*/
@RequestMapping("/")
public String toIndex() {
return "redirect:/hero/queryAll";
}
/*
* 这个方法的作用:会将请求中第一个/后的单词截取出来命名为path赋值给参数page
* 如 localhost:8080/web/hero,就会识别出hero,return "hero";
* 就会跳转到 /WEB-INF/pages/hero.jsp页面
* */
@RequestMapping("/{path}")
public String toPage(@PathVariable("path") String page) {
return page;
}
}
```
- 这时在页面中这样跳转
```jsp
<%--这个路径实际是/项目名/addHero,会截取addHero,跳转到/项目名/WEB-INF/pages/addHero.jsp--%>
<a href="${pageContext.request.contextPath}/addHero">添加</a>
```
# 文件上传
使用apche提供的通用文件上传组件实现。
## 1.导入所需依赖
```xml
<!--文件上传-->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.4</version>
</dependency>
2.向Spring容器中注入上传文件的核心类
在application.xml中注入通用多部件解析器CommonsMultipartResolver
<!--注入上传文件的核心类:通用多部件解析器CommonsMultipartResolver-->
<bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver" id="multipartResolver">
<!--设置上传的单个文件最大字节 10M:1024*1024*10-->
<property name="maxUploadSizePerFile" value="10485760"></property>
</bean>
3.上传页面的表单
<!--上传的表单控件使用file-->
<!--提交方式为post-->
<!--添加enctype="multipart/form-data"属性-->
<form action="/upload" method="post" enctype="multipart/form-data">
请选择图片<input type="file" name="uploadFile">
<input type="submit" value="上传">
</form>
4.控制层获取上传的文件
package com.hqyj.springmvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.IOException;
import java.util.UUID;
@Controller
@RequestMapping("/admin")
public class UploadController {
@RequestMapping("/upload")
public String upload(@RequestParam("uploadFile") MultipartFile uploadFile) throws IOException {//uploadFile就是上传的文件对象
//获取上传的文件名
String oldName = uploadFile.getOriginalFilename();
//得到源文件的后缀名
String prefix = oldName.substring(oldName.lastIndexOf("."));
//有可能不同的人上传的文件名相同,所以获取源文件的后缀后,生成一个随机文件名,拼接新文件名。
String newName = UUID.randomUUID()+prefix;
//创建一个文件File对象,
File file = new File("d:\\上传文件夹", newName);
//将文件写入硬盘中
uploadFile.transferTo(file);
return "welcome";
}
}
如果要在某个页面中显示上传的文件,要配置一个虚拟目录
配置Spring+SpringMVC时用到的关键类
- 在web.xml中配置Spring全局监听器
- ContextLoaderListener
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:application.xml</param-value>
</context-param>
- 在Springmvc配置文件中配置SpringMVC内部资源视图解析器
- InternalResourceViewResolver
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/pages/"></property>
<property name="suffix" value=".jsp"></property>
</bean>
- 在web.xml中配置SpringMVC请求分发Servlet
- DispatcherServlet
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
- 在web.xml中配置字符编码过滤器
- CharacterEncodingFilter
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
ORM
Object Relational Mapping 对象关系映射
创建Java类的对象,将其属性和数据库表中的字段名之间构建映射关系。
这样通过操作该类创建的一个对象,就能操作数据库中对应的数据表。
ORM框架就是对象关系映射框架,用于简化JDBC。
主流的ORM框架有Hibernate、JPA、MyBatis、MyBatisPlus等
MyBatis
一个半自动化的ORM框架。原本叫做ibatis,后来升级改名为MyBatis。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。
使用XML文件或注解的形式,将SQL语句映射为持久层(dao层)中的方法。
特点
方便
简化JDBC
解除SQL语句与业务代码的耦合
sql和java代码分离,sql写在xml文件中,方便扩展维护。
支持动态SQL
不同的情况下构造不同的SQL
主流
SSM中的M
![](https://i-blog.csdnimg.cn/blog_migrate/d6bd509c6a1489fc0d746c9b407395ca.jpeg)
SSM项目搭建补充
通过db.properties文件保存连接数据库的信息
.properties文件称为属性文件,其中的数据以键值对(key=value)的形式保存
-
在resources目录下新建db.properties文件
DB_DRIVER_CLASS_NAME=com.mysql.cj.jdbc.Driver DB_URL=jdbc:mysql://localhost:3306/bookdb?serverTimezone=Asia/Shanghai DB_USERNAME=root DB_PASSWORD=root
-
在application.xml中读取properties文件
<!--读取properties文件--> <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
-
读取时使用EL表达式访问其中的键
<!--Druid数据源DruidDataSource--> <bean class="com.alibaba.druid.pool.DruidDataSource" id="druidDataSource"> <property name="driverClassName" value="${DB_DRIVER_CLASS_NAME}"></property> <property name="url" value="${DB_URL}"></property> <property name="username" value="${DB_USERNAME}"></property> <property name="password" value="${DB_PASSWORD}"></property> </bean>
MyBatis配置文件常用设置
<?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>
<!--设置-->
<settings>
<!--开启驼峰命名映射-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
<!--开启SQL日志-->
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
</configuration>
MyBatis基本增删改查
dao层
package com.hqyj.ssm02.dao;
import com.hqyj.ssm02.entity.BookInfo;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface BookInfoDao {
//查询所有
List<BookInfo> queryAll();
//根据id删除
int delete(int id);
//添加
int insert(BookInfo bookInfo);
//根据id查询
BookInfo findById(int no);
//修改时,参数通常为一个完整的修改对象
int update(BookInfo bookInfo);
//批量删除
//分页查询
//关键字分页
//如果dao层中某个方法不止1个参数,需要给每个参数添加@Param("参数名")注解,给该参数命名
//命名后,才能在mybatis的sql映射文件中使用该参数,即#{参数名}
//如这里的newPrice,在sql中用#{newPrice}获取
int update(@Param("newPrice") int bookPrice,@Param("newNum") int bookNum,@Param("updateId") int bookId);
}
service层
package com.hqyj.ssm02.service;
import com.hqyj.ssm02.dao.BookInfoDao;
import com.hqyj.ssm02.entity.BookInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class BookInfoService {
@Autowired
private BookInfoDao bookInfoDao;
public List<BookInfo> queryAll() {
return bookInfoDao.queryAll();
}
public boolean delete(int id) {
return bookInfoDao.delete(id) > 0;
}
public void insert(BookInfo bookInfo) {
bookInfoDao.insert(bookInfo);
}
public BookInfo findById(int no) {
return bookInfoDao.findById(no);
}
public void update(BookInfo bookInfo) {
bookInfoDao.update(bookInfo);
}
}
controller层
package com.hqyj.ssm02.controller;
import com.hqyj.ssm02.entity.BookInfo;
import com.hqyj.ssm02.entity.BookType;
import com.hqyj.ssm02.service.BookInfoService;
import com.hqyj.ssm02.service.BookTypeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@Controller
@RequestMapping("/bookInfo")
public class BookInfoController {
@Autowired
private BookInfoService bookInfoService;
//注入BookTypeService,用于获取所有图书类型
@Autowired
private BookTypeService bookTypeService;
@RequestMapping("/queryAll")
public String queryAll(Model model) {
List<BookInfo> list = bookInfoService.queryAll();
model.addAttribute("list", list);
return "bookInfoList";
}
@RequestMapping("/delete")
public String delete(int id) {//如果在页面中传递的参数名和方法的形参名一致,会自动获取数据赋值
if (bookInfoService.delete(id)) {
//增删改执行后,使用重定向跳转
return "redirect:queryAll";
}
return "error";
}
@RequestMapping("/insert")
//如果表单提交的参数和方法的形参名一致,自动获取并赋值
//如果表单提交的所有参数正好是一个实体类对象,可以用对应的实体类对象获取
public String insert(BookInfo bookInfo){
bookInfoService.insert(bookInfo);
return "redirect:queryAll";
}
@RequestMapping("/findById")
//如果表单提交的参数名和方法的参数名不一致,使用@RequestParam("提交的参数名")
public String findById(@RequestParam("id") int no,Model model){
//查询对应的图书信息
BookInfo byId = bookInfoService.findById(no);
model.addAttribute("book",byId);
//查询所有的图书类型,保存到请求中
List<BookType> bookTypeList = bookTypeService.queryAll();
model.addAttribute("btList",bookTypeList);
return "bookEdit";
}
@RequestMapping("/update")
public String update(BookInfo bookInfo){
bookInfoService.update(bookInfo);
return "redirect:queryAll";
}
}
sql映射文件
<?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.hqyj.ssm02.dao.BookInfoDao">
<!--查询所有-->
<select id="queryAll" resultType="com.hqyj.ssm02.entity.BookInfo">
select *
from book_info
</select>
<!--根据id查询-->
<select id="findById" resultType="com.hqyj.ssm02.entity.BookInfo">
select *
from book_info
where book_id = #{no}
</select>
<!--根据id删除-->
<delete id="delete">
delete
from book_info
where book_id = #{id}
</delete>
<!--添加-->
<insert id="insert">
insert into book_info
values (null, #{typeId}, #{bookName}, #{bookAuthor}, #{bookPrice}, #{bookNum}, #{publisherDate}, #{bookImg})
</insert>
<!--修改-->
<update id="update">
update book_info
set book_price=#{newPrice},
book_num=#{newNum},
type_id=#{typeId}
where book_id = #{updateId}
</update>
</mapper>
使用BootStrap渲染数据
下载bootstrap的文件夹和jquery,保存到webapp根目录下。
由于在web.xml中,SpringMVC的核心类DispatcherServlet(请求分发器)的映射设置成了"/",表示所有请求,包含静态资源的请求都会交给SpringMVC处理。
解决无法引入静态资源的问题
-
在webapp目录下,新建一个目录,通常命名为static。将项目中的静态资源文件都保存于此。
-
在springmvc.xml中
<!--映射静态资源目录--> <!--location表示要映射的静态资源目录--> <!--mapping表示最终通过哪种方式进行访问。这里表示只要以/static开头的请求,都可以访问静态资源目录--> <mvc:resources mapping="/static/**" location="/static/"></mvc:resources> <!--开启注解驱动,有这个标签,SpringMVC就能区分哪个是资源文件,哪个是Controller--> <mvc:annotation-driven></mvc:annotation-driven>
导入BootStrap的样式和JS文件
<%--导入bootstrap的css文件--%>
<link href="${pageContext.request.contextPath}/static/bootstrap-3.4.1-dist/css/bootstrap.min.css" rel="stylesheet"
type="text/css">
<%--导入jquery--%>
<script src="${pageContext.request.contextPath}/static/bootstrap-3.4.1-dist/js/jquery-3.6.2.min.js"></script>
<%--导入boostrap的js文件--%>
<script src="${pageContext.request.contextPath}/static/bootstrap-3.4.1-dist/js/bootstrap.min.js"></script>
创建顶部导航页面
每个页面都需要这三句话,为了方便起见,给每个页面添加顶部导航页面top.jsp
这样其他页面只需要通过<jsp:include>
导入该页面的同时,使用BootStrap的样式和JS文件
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
<%--导入bootstrap的css文件--%>
<link href="${pageContext.request.contextPath}/static/bootstrap-3.4.1-dist/css/bootstrap.min.css" rel="stylesheet"
type="text/css">
<%--导入jquery--%>
<script src="${pageContext.request.contextPath}/static/bootstrap-3.4.1-dist/js/jquery-3.6.2.min.js"></script>
<%--导入boostrap的js文件--%>
<script src="${pageContext.request.contextPath}/static/bootstrap-3.4.1-dist/js/bootstrap.min.js"></script>
</head>
<body>
<nav class="navbar navbar-default">
<div class="container-fluid">
<!-- Brand and toggle get grouped for better mobile display -->
<div class="navbar-header">
<button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#bs-example-navbar-collapse-1" aria-expanded="false">
<span class="sr-only">Toggle navigation</span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
<span class="icon-bar"></span>
</button>
<a class="navbar-brand" href="#">Brand</a>
</div>
<!-- Collect the nav links, forms, and other content for toggling -->
<div class="collapse navbar-collapse" id="bs-example-navbar-collapse-1">
<ul class="nav navbar-nav">
<li class="active"><a href="#">Link <span class="sr-only">(current)</span></a></li>
<li><a href="#">Link</a></li>
<li class="dropdown">
<a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Dropdown <span class="caret"></span></a>
<ul class="dropdown-menu">
<li><a href="#">Action</a></li>
<li><a href="#">Another action</a></li>
<li><a href="#">Something else here</a></li>
<li role="separator" class="divider"></li>
<li><a href="#">Separated link</a></li>
<li role="separator" class="divider"></li>
<li><a href="#">One more separated link</a></li>
</ul>
</li>
</ul>
<form class="navbar-form navbar-left">
<div class="form-group">
<input type="text" class="form-control" placeholder="Search">
</div>
<button type="submit" class="btn btn-default">Submit</button>
</form>
<ul class="nav navbar-nav navbar-right">
<li><a href="#">Link</a></li>
<li class="dropdown">
<a href="#" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">Dropdown <span class="caret"></span></a>
<ul class="dropdown-menu">
<li><a href="#">Action</a></li>
<li><a href="#">Another action</a></li>
<li><a href="#">Something else here</a></li>
<li role="separator" class="divider"></li>
<li><a href="#">Separated link</a></li>
</ul>
</li>
</ul>
</div><!-- /.navbar-collapse -->
</div><!-- /.container-fluid -->
</nav>
</body>
</html>
列表页面
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--使用jsp动作包含一个子页面,也能使用其中的css和js文件--%>
<jsp:include page="top.jsp"></jsp:include>
<div class="row" style="width: 100%">
<div class="col-md-2"></div>
<div class="col-md-8">
<table class="table-striped table">
<tr>
<th>图书编号</th>
<th>类型编号</th>
<th>图书名称</th>
<th>图书作者</th>
<th>图书价格</th>
<th>图书库存</th>
<th>出版时间</th>
<th >操作</th>
<th><a href="${pageContext.request.contextPath}/bookAdd" class="btn btn-default btn-sm">添加</a></th>
</tr>
<c:forEach var="book" items="${list}">
<tr>
<td>${book.bookId}</td>
<td>${book.typeId}</td>
<td>${book.bookName}</td>
<td>${book.bookAuthor}</td>
<td>${book.bookPrice}</td>
<td>${book.bookNum}</td>
<td>${book.publisherDate}</td>
<td><a href="${pageContext.request.contextPath}/bookInfo/findById?id=${book.bookId}" class="btn btn-primary btn-sm">编辑</a></td>
<td><a href="${pageContext.request.contextPath}/bookInfo/delete?id=${book.bookId}" class="btn btn-danger btn-sm">删除</a></td>
</tr>
</c:forEach>
</table>
</div>
<div class="col-md-2"></div>
</div>
</body>
</html>
详情页面
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<jsp:include page="top.jsp"></jsp:include>
<div class="row">
<div class="col-md-3"></div>
<div class="col-md-6">
<form class="form-horizontal" action="${pageContext.request.contextPath}/bookInfo/update" method="post">
<%--隐藏域提交id--%>
<input type="hidden" name="bookId" value="${book.bookId}">
<div class="form-group">
<label class="col-sm-2 control-label">图书名称</label>
<div class="col-sm-10">
<input type="text" readonly class="form-control" value="${book.bookName}" name="bookName" placeholder="请输入图书名称" required>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">图书作者</label>
<div class="col-sm-10">
<input type="text" readonly class="form-control" value="${book.bookAuthor}" name="bookAuthor" placeholder="请输入图书作者" required>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">图书类型</label>
<div class="col-sm-10">
<select class="form-control" name="typeId" >
<%--遍历所有的图书类型--%>
<c:forEach items="${btList}" var="bt">
<option value="${bt.typeId}" ${bt.typeId==book.typeId?"selected":""}>${bt.typeName}</option>
</c:forEach>
</select>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">图书价格</label>
<div class="col-sm-10">
<input type="number" min="1" class="form-control" value="${book.bookPrice}" name="bookPrice" placeholder="请输入图书价格" required>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">图书库存</label>
<div class="col-sm-10">
<input type="number" min="1" class="form-control" value="${book.bookNum}" name="bookNum" placeholder="请输入图书库存" required>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">出版时间</label>
<div class="col-sm-10">
<input type="date" readonly class="form-control" value="${book.publisherDate}" name="publisherDate" required>
</div>
</div>
<div class="form-group">
<div class="col-sm-offset-2 col-sm-10">
<button type="submit" class="btn btn-default">修改</button>
</div>
</div>
</form>
</div>
<div class="col-md-3"></div>
</div>
</body>
</html>
添加页面
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2023/1/30
Time: 14:17
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<jsp:include page="top.jsp"></jsp:include>
<div class="row">
<div class="col-md-3"></div>
<div class="col-md-6">
<form class="form-horizontal" action="${pageContext.request.contextPath}/bookInfo/insert" method="post">
<div class="form-group">
<label class="col-sm-2 control-label">图书名称</label>
<div class="col-sm-10">
<input type="text" class="form-control" name="bookName" placeholder="请输入图书名称" required>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">图书作者</label>
<div class="col-sm-10">
<input type="text" class="form-control" name="bookAuthor" placeholder="请输入图书作者" required>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">图书类型</label>
<div class="col-sm-10">
<select class="form-control" name="typeId">
</select>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">图书价格</label>
<div class="col-sm-10">
<input type="number" min="1" class="form-control" name="bookPrice" placeholder="请输入图书价格" required>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">图书库存</label>
<div class="col-sm-10">
<input type="number" min="1" class="form-control" name="bookNum" placeholder="请输入图书库存" required>
</div>
</div>
<div class="form-group">
<label class="col-sm-2 control-label">出版时间</label>
<div class="col-sm-10">
<input type="date" class="form-control" name="publisherDate" required>
</div>
</div>
<div class="form-group">
<div class="col-sm-offset-2 col-sm-10">
<button type="submit" class="btn btn-default">添加</button>
</div>
</div>
</form>
</div>
<div class="col-md-3"></div>
</div>
</body>
<script>
/*
使用ajax查询所有图书类型
在页面中使用ajax访问后端如果要得到数据,该数据必须是JSON格式
*/
$.ajax({
//请求地址
url: "${pageContext.request.contextPath}/bookType/queryAllToJson",
//访问成功后的回调函数
success: function (res) {//这里的res是所有类型对象的集合
for (var i = 0; i < res.length; i++) {
var $opt = $("<option value='" + res[i].typeId + "'>" + res[i].typeName + "</option>")
$("select[name=typeId]").append($opt);
}
}
});
</script>
</html>
在SpringMVC中,让某个控制层中的方法返回JSON格式的数据
-
添加依赖
<!--jackson:将数据转换为JSON格式--> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.14.2</version> </dependency>
-
@ResponseBody注解
该注解可以加在类或方法上
- 如果加在方法上,表示该方法的返回值类型为JSON格式
- 如果加在类上,表示该类中的所有方法的返回值类型为JSON格式
package com.hqyj.ssm02.controller; import com.hqyj.ssm02.entity.BookType; import com.hqyj.ssm02.service.BookTypeService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; import java.util.List; @Controller @RequestMapping("/bookType") public class BookTypeController { @Autowired private BookTypeService bookTypeService;
//如果controller的某个方法返回一个JSON字符串,需要使用@ResponseBody
@RequestMapping("/queryAllToJson")
@ResponseBody//表示该方法无论返回值是什么,都返回JSON格式字符串
public List<BookType> queryAllToJson(){
List<BookType> list = bookTypeService.queryAll();
return list;
}
}
# SSM项目中使用Ajax
ajax依赖于jquery,所以先保证页面中存在jquery.js。
```js
$.ajax({
url:"访问地址",
data:{
"提交的参数名":"实际值",
"提交的参数名":"实际值"
},
type:"get/post",
success:function(res){
//成功后的回调函数,res为访问后的结果,必须是json格式
}
});
在前端页面中使用ajax访问controller时,controller的返回值必须是一个JSON格式的字符串。
所以controller中的方法上要加入@ResponseBody注解
使用Aajx实现注册和登录
表
当前表为customer,包含字段如下
![image20230131154742977](file://D:\Desktop\框架 2\SSM03.assets\image-20230131154742977.png?msec=1676454902974)
使用该表中的phone和password作为登录时的账户和密码
实体类
package com.hqyj.ssm02.entity;
/*
* 对应customer表
* */
public class SysAdmin {
//用户名adminName属性对应phone字段
private String adminName;
//密码adminPwd属性对应password字段
private String adminPwd;
//省略get/set/toString
}
注册
注册时先判断用户名是否存在,如果存在则不能注册
-
dao
/*查询用户名是否存在,返回查询到的数量*/ int findByAdminName(String adminName); /*添加*/ int insert(SysAdmin sysAdmin);
-
mapper.xml
<!--查询用户名(phone)是否存在--> <select id="findByAdminName" resultType="java.lang.Integer"> select count(*) from customer where phone = #{adminName} </select> <!--添加用户--> <insert id="insert"> insert into customer values (null, #{adminName}, #{adminPwd}, 0, null) </insert>
-
service
/* * 检查注册的用户名是否存在 * */ public boolean findAdminName(SysAdmin sysAdmin) { //查询要注册的用户名是否存在 int i = sysAdminDao.findByAdminName(sysAdmin.getAdminName()); if (i != 0) { return false; } return true; } /* * 注册 * */ public boolean register(SysAdmin sysAdmin) { return sysAdminDao.insert(sysAdmin) > 0; }
-
controller
/* * 查询名称是否存在,返回boolean类型的json字符串 * */ @RequestMapping("/findAdminName") @ResponseBody public boolean findAdminName(SysAdmin sysAdmin) { return sysAdminService.findAdminName(sysAdmin); } /* * 注册成功后跳转到登录页面 * */ @RequestMapping("/register") public String register(SysAdmin sysAdmin) { sysAdminService.register(sysAdmin); return "login"; }
-
页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> <style> .cus-portrait { margin: 0 auto; width: 100px; height: 100px; border: 1px solid #337ab7; text-align: center; line-height: 100px; border-radius: 50px; } </style> </head> <body> <jsp:include page="top.jsp"></jsp:include> <div class="col-md-4"></div> <div class="col-md-4"> <div class="panel panel-primary"> <div class="panel-heading">用户注册</div> <div class="panel-body"> <form action="${pageContext.request.contextPath}/sysAdmin/register" method="post"> <div class="form-group"> <label class="warning">用户名</label> <input type="text" class="form-control" required name="adminName" placeholder="请输入用户名"> </div> <div class="form-group"> <label>密码</label> <input type="password" class="form-control" required name="adminPwd" placeholder="请输入密码"> </div> <button type="submit" class="btn btn-default">注册</button> </form> </div> </div> </div> <div class="col-md-4"></div> <script> $(function () { //用户名文本框失去焦点触发 $("input[name=adminName]").blur(function () { $.ajax({ //访问controller url:"${pageContext.request.contextPath}/sysAdmin/findAdminName", data:{ //提交数据 "adminName":$(this).val() }, success:function(res){ //res是true、false。true表示该用户名不存在 if(res){ $(".warning").text("√").css("color","green"); $("button[type=submit]").removeAttr("disabled"); }else{ $(".warning").text("该用户名已存在").css("color","red"); $("button[type=submit]").attr("disabled","disabled"); } } }); }); }); </script> </body> </html>
登录
-
dao
/*登录*/ SysAdmin login(SysAdmin sysAdmin);
-
mapper.xml
<!--登录--> <!--如果查询的字段名和实体的属性名不一致,需要自定义查询结果集映射--> <select id="login" resultMap="loginMap"> select * from customer where phone = #{adminName} and password = #{adminPwd} </select> <!--自定义返回结果集映射--> <resultMap id="loginMap" type="com.hqyj.ssm02.entity.SysAdmin"> <!--表中的phone字段对应SysAdmin对象的adminName字段--> <result property="adminName" column="phone"></result> <result property="adminPwd" column="password"></result> </resultMap>
-
service
/* * 登录 * */ public SysAdmin login(SysAdmin sysAdmin){ return sysAdminDao.login(sysAdmin); }
-
controller
@RequestMapping("/login") @ResponseBody public SysAdmin login(SysAdmin sysAdmin,Model model) { SysAdmin login = sysAdminService.login(sysAdmin); //将登录成功的对象保存到session中 model.addAttribute("sysAdmin",login); return login; }
-
页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %> <html> <head> <title>Title</title> </head> <body> <jsp:include page="top.jsp"></jsp:include> <div class="col-md-4"></div> <div class="col-md-4"> <div class="panel panel-primary"> <div class="panel-heading">用户登录</div> <div class="panel-body"> <div class="form-group"> <label>用户名</label> <input type="text" class="form-control" required id="name" placeholder="请输入用户名"> </div> <div class="form-group"> <label>密码</label> <input type="password" class="form-control" required id="pwd" placeholder="请输入密码"> </div> <div class="form-group"> <label class="warning">验证码</label> <span class="vcode"></span> <input type="text" class="form-control inpVcode" required placeholder="请输入验证码"> </div> <a class="btn btn-default loginBtn">登录</a> <a class="btn btn-default" href="">注册</a> </div> </div> </div> <div class="col-md-4"></div> <script> //1000~9999 var vcode = Math.floor(Math.random() * 8999 + 1000); //显示验证码 $(".vcode").text(vcode).css("font-weight", "bolder"); //定义一个boolean值用于提交数据时判断验证码是否有误,默认false var goon=false; //bind("绑定事件名",满足时触发的函数) input propertychange表示监听文本框输入事件(只要内容有变化就触发) $(".inpVcode").bind("input propertychange", function () { if (vcode != $(this).val()) {//如果验证码有误,改变警告文字 $(".warning").text("验证码输入错误").css("color","#f00"); }else{ //如果输入正确,改变boolean值为true $(".warning").text("√").css("color","#0f0"); goon=true; } }); //登录按钮单击 $(".loginBtn").click(function () { //判断验证码 if (!goon) { return; } //使用ajax提交数据进行登录 $.ajax({ url:"${pageContext.request.contextPath}/sysAdmin/login", data:{ "adminName":$("#name").val(), "adminPwd":$("#pwd").val() }, success:function (res){ if(res!=""){ location.href="${pageContext.request.contextPath}/bookInfo/queryAll"; }else{ alert("用户名或密码错误"); } } }); }); </script> </body> </html>
在SpringMVC中使用Session
方式一:@SessionAttributes注解
由于SSM项目中,没有使用servlet,所以不能通过request.getSession()方法来获取session对象。
在控制器Controller中,在类上加入@SessionAttributes注解
**@SessionAttributes({"参数1","参数2"})**表示在session中保存两个参数
再在某个方法中,通过Model对象调用addAttribute("参数1",对象)方法将指定对象保存到session中
使用和销毁
@Controller
@RequestMapping("/sysAdmin")
//如果要将数据保存到session中,先使用该注解定义session中的参数名
@SessionAttributes({"sysAdmin"})
public class SysAdminController {
@Autowired
SysAdminService sysAdminService;
@RequestMapping("/login")
@ResponseBody
public SysAdmin login(SysAdmin sysAdmin,Model model) {
SysAdmin login = sysAdminService.login(sysAdmin);
//将登录成功的对象保存到session中
model.addAttribute("sysAdmin",login);
return login;
}
/*登出时销毁session*/
@RequestMapping("/logout")
public String logout(SessionStatus sessionStatus) {
//在方法中使用SessionStatus参数表示session状态对象
//调用setComplete()方法,将session设置为完成状态
sessionStatus.setComplete();
return "redirect:/login";
}
}
方式二:HttpSession参数
给项目添加javax.servlet.api依赖,给controller中某个方法添加HttpSession参数后,获取session使用
<!--如果要使用servlet相关内容-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
使用和销毁
拦截器
每次请求controller时,都要经过的一个类。
当一个项目中有过滤器、拦截器和controller时的执行流程
实现过程
1.导入servlet依赖
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
2.自定义一个类,实现拦截器HandlerInterceptor接口
其中有三个default方法可以重写
- preHandle
- 在发送请求后,DispatcherServlet解析控制器中某个RequestMapping之前执行的方法
- 该方法返回true时,请求才能继续
- postHandle
- 在preHandle方法返回值为true后执行
- 在DispatcherServlet解析控制器中某个RequestMapping之后执行
- afterCompletion
- 在preHandle方法返回true后执行
- 在解析视图后执行的方法
这里只需重写preHandle方法即可
package com.hqyj.ssm02.interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/*
* 自定义拦截器,用户拦截未登录时的请求
* */
public class MyInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String requestURI = request.getRequestURI();
//登录成功后,会在session中保存一个名为sysAdmin的对象
Object sysAdmin = request.getSession().getAttribute("sysAdmin");
//如果有对象,说明登录成功,可以放行return true
if(sysAdmin!=null){
return true;
}else{
response.sendRedirect(request.getContextPath()+"/login");
}
System.out.println(requestURI+"试图访问,拦截成功");
return false;
}
}
多条件查询
参考#{}的用法
#{}和${}
通常使用#{},防止sql注入
-- #{}会自动用''将参数引起来,如参数为admin
select * from user where username=#{username}
select * from user where username='admin'
-- ${}会将参数原样拼接,如参数为admin
select * from user where username=${username}
select * from user where username=admin
#{}的使用
-
如果dao层接口中的方法参数为一个原始类型或字符串时
-
sql语句#{}中的参数是接口中方法的形参名
-
public interface UserDao{ User findById(int userId); }
<select id="findById" resultType="com.xxx.entity.User"> select * from user where id=#{userId} </select>
-
-
如果dao层接口中的方法参数为一个实体对象时**
- sql语句#{}中的参数必须是接口中方法参数的某个属性
public interface UserDao{ User login(User user); }
<select id="login" resultType="com.xxx.entity.User"> select * from user where username=#{username} and password=#{password} </select>
-
如果dao层接口中的方法参数不止一个时
-
给每个参数添加@Param("自定义参数名")
-
sql语句#{}中的参数必须是@Param注解中自定义的名称
-
public interface UserDao{
User update(@Param("bianhao")int id,@Param("mima")String password);
}
<update id="update">
update user set password=#{mima} where id=#{bianhao}
</update>
${}的使用
当需要拼接的参数不能带引号时,必须使用${},如动态表名、排序条件等
动态表名
select * from ${表名}
排序条件
select * from 表名 order by ${字段}
SpringBoot
Spring推出的一个Spring框架的脚手架。
不是一个新的框架,而是搭建Spring相关内容框架的平台。
它省去了Spring、SpringMVC项目繁琐的配置过程,让开发变得更加简单。
本质还是Spring+SpringMVC,可以搭配其他的ORM框架,如MyBatis、MyBatisPlus、JPA、Hibernate等。
特点
- 内置了Tomcat服务器,不需要部署项目到Tomcat中
- 内置了数据源Hikari
- 减少了jar文件依赖的配置
- SpringBoot中的配置文件可以使用yml格式文件,代替properties或xml
创建SpringBoot项目
通过IDEA创建
SpringBoot+MyBatis实现单表查询
1.创建好SpringBoot项目
最好在创建的时候选择以下依赖
- spring-web(必选)
- lombok
- spring-devtools
- springboot集成mybatis
- mysql驱动
都可以后续添加
<!--web-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--热部署-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<version>2.7.8</version>
</dependency>
<!--Lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
<scope>provided</scope>
</dependency>
2.在pom.xml中添加mybatis集成SpringBoot依赖和数据库驱动
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.31</version>
</dependency>
<!--springboot集成MyBatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.3.0</version>
</dependency>
3.在springboot配置文件application.properties中
#注释
#.properties文件称为属性文件,数据以键值对"键=值"的形式保存
#设置项目启动端口号
#server.port=9090
#设置项目上下文路径
#server.servlet.context-path=/springbootday1
#mybatis相关配置
#开启驼峰命名映射
mybatis.configuration.map-underscore-to-camel-case=true
#打印sql语句
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
#扫描mybatis的sql映射文件(将mapper.xml文件保存在resources目录下的mapper目录下)
mybatis.mapper-locations=classpath:mapper/*.xml
#数据库信息
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/gamedb?serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
mybatis的sql映射文件模板
<?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">
<!--设置该文件对应的dao层接口全限定名-->
<mapper namespace="">
</mapper>
4.根据数据表创建实体类、dao层接口、service、controller
![image20230203154807705](file://D:\Desktop\框架 2\day10-SpringBoot+MyBatis1.assets\image-20230203154807705.png?msec=1676455514708)
Hero
@Data
public class Hero{
private Integer id;
private String name;
private String position;
private String sex;
private Double price;
private String shelfDate;
}
dao
@Repository
public interface HeroDao{
List<Hero> queryAll();
}
mapper.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">
<!--设置该文件对应的dao层接口全限定名-->
<mapper namespace="com.xxx.dao.HeroDao">
<select id="queryAll" resultType="com.xxx.entity.Hero">
select * from hero
</select>
</mapper>
service
@Service
public class HeroService{
@Autowired
private HeroDao heroDao;
public List<Hero> queryAll(){
return heroDao.queryAll();
}
}
controller
@Controller
@RequestMapping("/hero")
public class HeroController{
@Autowired
private HeroService heroService;
@RequestMapping("/queryAll")
@ResponseBody
public List<Hero> queryAll(){
return heroDao.queryAll();
}
}
5.在SpringBoot的启动类上,加入@MapperScan注解,扫描dao层所在根包
@SpringBootApplication
//扫描dao层所在的根包
@MapperScan("com.hqyj.first.dao")
public class FirstApplication {
public static void main(String[] args) {
SpringApplication.run(FirstApplication.class, args);
}
}
启动项目,按自定的项目上下文路径和端口号访问某个controller中的方法
Spring Data JPA
2001年推出了Hibernate,是一个全自动ORM框架。可以不用编写SQL语句,就能实现对数据库的持久化操作。
SUN公司在Hibernate的基础上,制定了JPA,全称 Java Persisitence API,中文名Java持久化API,
是一套Java访问数据库的规范,由一系列接口和抽象类构成。
后来Spring团队在SUN公司制定的JPA这套规范下,推出了Spring Data JPA,是JPA的具体实现。
如今常说的JPA,通常指Spring Data JPA。
SpringBoot集成Spring Data JPA
1.创建SpringBoot项目,选择依赖
2.编辑配置文件,设置要连接的数据库信息
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/bookdb?serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
# 设置数据库类型
spring.jpa.database=mysql
# 打印SQL语句
spring.jpa.show-sql=true
3.创建实体类
-
类上加**@Entity**注解
-
主键属性上加
-
@Id注解标明主键
-
**@GeneratedValue(strategy = GenerationType.IDENTITY)**设置MySQL数据库主键生成策略,数据库设置为自增
-
-
其他属性名与字段名一致或驼峰命名法
- 如果字段名多个单词之间用_,使用驼峰命名法
- 如果不相同,使用**@Column(name="字段名")**注解指定该属性对应的字段名
@Data
@Entity
/*
* 实体类的属性名建议使用驼峰命名法
* */
public class BookInfo {
@Id//主键字段
//主键生成策略,GenerationType.IDENTITY表示MySQL自增
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer bookId;
private Integer typeId;
private String bookName;
private String bookAuthor;
//如果字段名和属性名不一致,使用@Column指定字段名
@Column(name = "book_price")
private Integer price;
private Integer bookNum;
private String publisher_date;
}
4.数据访问层接口
- 类上加@Repository注解
- 继承JpaRepository<实体类型,主键类型>接口
@Repository
public interface BookInfoDao extends JpaRepository<BookInfo,Integer> {
}
5.测试常用方法
方法名 | 返回值 | 作用 |
---|---|---|
findAll() | List | 查询所有数据。 |
save(T entity) | T entity | 添加或修改。如果不存在主键属性或主键值不存在,执行添加;如果存在主键属性且有该主键值,执行修改。 |
delete(T entity) | void | 根据对象删除。如果该对象中有主键属性且有该主键值,根据该主键值删除。 |
findById(主键) | Optional | 根据主键值查询。返回的对象调用isPresent()结果为true,表示查询到了数据,继续调用get()得到查询到的对象。 |
@SpringBootTest
class Day16SpringBootJpaApplicationTests {
@Autowired
private BookInfoDao bookInfoDao;
@Test
void contextLoads() {
List<BookInfo> all = bookInfoDao.findAll();
all.forEach(System.out::println);
}
@Test
void insert() {
BookInfo bookInfo = new BookInfo();
bookInfo.setBookName("测试");
bookInfo.setBookAuthor("测试");
bookInfo.setBookNum(156);
bookInfo.setPrice(20);
bookInfo.setTypeId(1);
//save()方法调用时,如果对象中没有主键或主键值不存在,作为添加使用
BookInfo save = bookInfoDao.save(bookInfo);
//添加成功后,会自动获取主键自增的值
System.out.println(save);
}
@Test
void update() {
BookInfo bookInfo = new BookInfo();
bookInfo.setBookName("xxxxxxxxxxx");
bookInfo.setBookAuthor("测试");
bookInfo.setBookNum(356);
bookInfo.setPrice(23);
bookInfo.setTypeId(1);
//save()方法调用时,如果对象中有主键且存在,作为修改使用
BookInfo save = bookInfoDao.save(bookInfo);
//修改成功后,返回修改后的对象
System.out.println(save);
}
@Test
void delete() {
//根据主键值删除,如果值不存在,会报错
//bookInfoDao.deleteById(36);
//根据对象删除,如果对象中包含主键值则删除,如果没有值或不存在,不会报错
BookInfo bookInfo = new BookInfo();
//bookInfo.setBookId(330);
bookInfoDao.delete(bookInfo);
}
@Test
void findOne() {
//根据主键查询,返回值Optional类型
Optional<BookInfo> byId = bookInfoDao.findById(60);
//isPresent()如果为true表示查询到了数据
if (byId.isPresent()) {
//get()将查询到的数据转换为对应的实体类
BookInfo bookInfo=byId.get();
System.out.println(bookInfo);
}else{
System.out.println("未查询到数据");
}
}
}
JPA进阶
分页查询
调用数据访问层中的**findAll(Pageable pageable)**方法,即可实现分页。
参数Pageable是org.springframework.data.domain包中的一个接口,通过其实现类
PageRequest,调用静态方法of(int page,int size),当做Pageable对象使用。
这里的page从0开始为第一页。
@Test
void queryByPage(){
//PageRequest是Pageable的实现类,调用静态方法of(int page,int size)
//这里的page的值0表示第一页
//调用findAll(Pageable pageable)方法,返回分页模型对象
Page<BookInfo> pageInfo = bookInfoDao.findAll(PageRequest.of(0,5));
//分页相关数据
System.out.println("总记录数"+pageInfo.getTotalElements());
System.out.println("最大页数"+pageInfo.getTotalPages());
System.out.println("分页后的数据集合"+pageInfo.getContent());
System.out.println("当前页数"+pageInfo.getNumber());
System.out.println("每页显示的记录数"+pageInfo.getSize());
System.out.println("是否还有下一页"+pageInfo.hasNext());
System.out.println("是否还有上一页"+pageInfo.hasPrevious());
}
条件查询
在JPA中,使用自定义方法名自动生成对应的SQL语句,实现条件查询。
如在dao中定义了queryById(int id)方法,就表示根据id查询,自动生成sql语句。
方法命名格式
[xxx] [By] [字段对应的属性名] [规则] [Or/And] [字段对应的属性名] [规则] ...
- **xxx可以是find、get、query、search
- 方法如果有参数,参数的顺序和方法名中的参数顺序一致
如findByBookNameAndBookAuthor(String bookName,String bookAuthor),
对应的sql语句为 select * from book where book_name =? and book_author=?
常用规则
规则 | 方法名 | SQL中的条件 |
---|---|---|
指定值 | findByBookName(String name) | book_name = name |
Or/And | findByBookNameOrBookAuthor(String name,String author) | book_name = name or book_author = author |
After/Befor | findByBookPriceAfter(double price) | book_price > price |
GreaterThanEqual/LessThanEqual | findByBookNumLessThanEqual(int num) | book_num <= num |
Between | findByBookNumBetween(int min,int max) | book_num between min and max |
Is[Not]Null | findByPublisherDateIsNull() | publish_date is null |
[Not]Like | findByBookNameLike(String condition) | book_name like 'condition' |
[Not]Contains | findByBookNameContains(String keyword) | book_name like '%keyword%' |
StartsWith/EndsWith | findByBookNameStartsWith(String firstName) | book_name like 'firstName%' |
无条件排序:findAllByOrderBy字段[Desc/Asc] | findAllByOrderByBookId() | order by book_id asc |
有条件排序:findAllBy条件OrderBy字段[Desc/Asc] | findAllByTypeIdOrderByBookIdDesc() | type_id = ? order by book_id desc |
@Repository
public interface BookInfoDao extends JpaRepository<BookInfo,Integer> {
//指定值查询
//根据书名查询
List<BookInfo> getAllByBookName(String x);
//查询价格大于指定值 字段对应的属性名 After/GreaterThan
List<BookInfo> findAllByPriceAfter(int price);
//查询价格小于于指定值 字段对应的属性名 Before/LessThan
List<BookInfo> findAllByPriceLessThan(int price);
//查询库存大于等于指定值 GreaterThanEqual
List<BookInfo> queryAllByBookNumGreaterThanEqual(int num);
//查询库存在指定闭区间内 Between(int min,int max)
List<BookInfo> findAllByBookNumBetween(int min,int max);
//空值查询 null
//查询出版日期为空 IsNull/IsNotNull
List<BookInfo> findAllByPublisherDateIsNull();
//书名中带有关键字 Like/NotLike 实参一定要使用%或_
List<BookInfo> getAllByBookNameLike(String keyword);
//作者名中带有关键字 Contains/NotContains 实参只需要关键字
List<BookInfo> getAllByBookAuthorContains(String keyword);
//指定作者的姓 指定开头/结尾 StartsWith/EndsWith
List<BookInfo> getAllByBookAuthorStartsWith(String keyword);
//查询所有数据,按价格降序 无条件排序 OrderBy字段[Desc/Asc]
List<BookInfo> getAllByOrderByPriceDesc();
//查询指定类型,按id降序
List<BookInfo> getAllByTypeIdOrderByBookIdDesc(Integer typeId);
}
条件分页查询
只需在定义方法时,将方法的返回值设置为Page类型,在参数中就如Pageable对象
//根据作者和书名的关键字分页查询
Page<BookInfo> getAllByBookNameContainsOrBookAuthorContains(
String nameKeyword,
String authorKeyword,
Pageable pageable);
Page<BookInfo> pageInfo = bookInfoDao.getAllByBookNameContainsOrBookAuthorContains("龙","山",PageRequest.of(0,5));
//分页相关数据保存在pageInfo对象中
聚合函数分组查询
自定义SQL
在数据访问层接口中的方法上,可以加入@Query注解,默认要使用HQL(Hibernate专用)格式的语句。
如果要使用原生的SQL语句,需要添加nativeQuery=true属性,用value属性定义SQL语句
/*
* 在JPA中,如果要使用自定义的SQL语句
* nativeQuery = true 开启原生SQL语句
* value="sql语句"
* */
@Query(nativeQuery = true, value = "select book_author,count(book_id) from book_info group by book_author")
List testQuery();
@Test
void test(){
List list = bookInfoDao.testQuery();
//查询的结果为集合,集合中保存的是每一行数据
for (Object row : list) {
//每一行页数一个对象数组
Object[] obj= (Object[])row;
//根据索引得到查询出的内容
System.out.println(obj[0]+"---"+obj[1]);
}
}
自定义SQL中带参数
SQL语句中的":XXX"表示参数
如果方法的形参名和xxx一致时直接使用,如果不一致,在形参上加入@Param注解设置形参名
/*
* 根据作者查询其图书总库存
* 使用":形参名"在SQL语句中带参数
* 在方法中通过@Prama定义形参
* */
@Query(nativeQuery = true, value = " select book_author,sum(book_num) from book_info where book_author=:zuozhe")
List testQuery3(@Param("zuozhe") String xxx);
@Test
void test(){
List list = bookInfoDao.testQuery3("金庸");
//查询的结果为集合,集合中保存的是每一行数据
for (Object row : list) {
//每一行页数一个对象数组
Object[] obj= (Object[])row;
//根据索引得到查询出的内容
System.out.println(obj[0]+"---"+obj[1]);
}
}
关联查询
实体类
主表实体BookType
@Entity
@Data
public class BookType {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer typeId;
private String typeName;
}
从表实体BookInfo
- 无需写出外键字段属性
- 额外添加外键字段对应的实体类对象属性
@Data
@Entity
public class BookInfo {
@Id//主键字段
//主键生成策略,GenerationType.IDENTITY表示MySQL自增
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer bookId;
//private Integer typeId;
private String bookName;
private String bookAuthor;
//如果字段名和属性名不一致,使用@Column指定字段名
@Column(name = "book_price")
private Integer price;
private Integer bookNum;
private String publisherDate;
//多对一查询,以当前从表信息为主体,关联相应的主表信息
@JoinColumn(name = "type_id")//使用type_id字段进行多对一查询
@ManyToOne//多对一
private BookType bt;
}
使用
-
多对一查询,调用dao中的查询方法,就会自动给外键字段对应的对象赋值
-
添加时,参数所需外键字段,使用外键字段对应的对象名代替
//添加 @PostMapping("/book") public RestResult<BookInfo> insert(BookInfo bookInfo) { return RestResult.ok("添加成功", bookInfoDao.save(bookInfo)); }
-
如果根据外键字段查询,要在从表dao中定义方法findBy外键对象名_外键对象属性名(数据类型 外键字段)
//如果根据外键字段查询,方法名写为 By外键实体类属性名_属性名 List<BookInfo> getAllByBt_TypeId(Integer typeId);
前后端分离项目
前后端分离,就是将web应用中的前端页面和后端代码分开完成、部署。
- 前后端的开发者只需要完成各自的事情,最终以文档的形式约定数据接口(URL、参数、返回值、请求方式)
- 前后端分别用独立的服务器
- 后端只需处理数据并提供访问接口(路径),以RESTFul风格的JSON格式传输数据
- 前端只需负责渲染页面和展示数据
传统项目和前后端分离项目对比
传统项目
前端和后端的代码运行在一个服务器上,页面经由控制器跳转
SSM项目、图书管理系统、答题系统
前后端分离项目
前后端的代码分别运行在各自的服务器上
后端提供JSON格式字符串的数据接口
前端负责跳转、解析JSON数据。
酒店客房管理系统
前后端分离项目后端控制层设计
请求方式设计:RESTFul风格
风格,不是标准,可以不用强制遵循。
RESTFul风格:用不同的请求方式去访问同一个URL地址时,执行不同的操作。
特点
- 通过URL就能知道当前在哪个模块
- 通过不同的请求方式决定执行什么操作
- 通过返回的状态码得到操作结果
使用RESTFul风格和普通方式对比
普通方式
localhost:8080/user/queryAll 查询所有
localhost:8080/user/queryById?id=1001 条件查询
localhost:8080/user/insert?name=ez&sex=男&age=20 添加
localhost:8080/user/update?name=ez&id=1001 修改
localhost:8080/user/delete?id=1001 删除
RESTFul风格
localhost:8080/user 查询所有get请求
localhost:8080/user/1001 条件查询get请求
localhost:8080/user 添加post请求
localhost:8080/user 修改put请求
localhost:8080/user/1001 删除delete请求
RESTFul风格具体使用
-
在请求映射的命名上,统一用小写字母的名词形式表示当前位于哪个模块。如/user、/book_info
-
访问时如果要传参,使用"/模块名/参数"方式,配合controller中的@PathVariable获取
@GetMapping("/book/{id}") public BookInfo queryById(@PathVariable("id")Integer id){ return service.findById(id); }
-
在controller的方法上,使用@XXXMapping()设置访问该方法的请求方式
- @GetMapping("路径") 查询
- @PostMapping("路径") 添加
- *@PutMapping("路径") * 修改
- *@DeleteMapping("路径") * 删除
- @RequestMapping(value="路径",method=RequestMethod.GET/POST/PUT/DELETE))
-
如果请求方式不匹配,会报405异常
-
在同一个controller中,不能出现两个请求方式和路径都一致的方法
返回值设计
前后端分离项目的控制层方法的返回值也需要进行统一。
返回值通常包含以下信息
- 传递状态,用状态码表示Integer code
- 传递消息,用字符串表示String msg
- 传递集合,用集合表示List list
- 传递对象,用对象表示Object obj
将这些信息封装到一个对象中,这个对象称为返回结果类RestResult对象
RestResult类具体设计
Postman
Postman API Platform | Sign Up for Free
Java技术栈
服务器端
JavaSE(API、OOP)、JavaEE(Servlet、Spring、SpringMVC)
tomcat
前端0
HTML+CSS+JS+JQUERY、Bootstrap、LayUI、EasyUI、VUE
数据库
MySQL、Oracle、Redis
JDBC、SpringJDBC、MyBatis、MyBatisPlus、JPA
工具
IDEA、HBuilder、VSCode、Notepad++、Sublime、Navicat、Postman
JavaEE过程
Servlet + JDBC + JSP(bootstrap) 图书商场
Spring + SpringMVC + SpringJDBC + JSP(bootstrap)
Spring + SpringMVC + MyBatis+ JSP 图书管理系统SSM
SpringBoot + MyBatis + html(LayUI) 酒店客房管理(可前后端分离)
SpringBoot + MyBatisPlus + html(Thymeleaf+bootstrap) 答题系统
SpringBoot + Spring Data JPA
项目一
SpringBoot+MyBatisPlus+Vue 仓库管理(前后端分离)