spring笔记-CSDN博客

本文链接：https://blog.csdn.net/qq_60585212/article/details/120367126

Spring

练习前后端整合，包括入库

Java代码

package cn.tedu.hello;

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;

@RestController

@RequestMapping("car")

public class CarController2 {

//1,解析浏览器发来的请求参数

//http://localhost:8080/car/save3?

//id=1&color=red&price=100&pinpai=BMW&type=X7

@RequestMapping("save3")

public Object save3(Car c) throws Exception {

//TODO 把解析到的请求参数 getXxx()入库--jdbc

//1,pom里加jdbc的坐标

//2,在数据库里创建car表(提供id,color,price,pinpai,type字段)

/* CREATE TABLE car(

id INT PRIMARY KEY AUTO_INCREMENT,

color VARCHAR(20),

price DOUBLE,

pinpai VARCHAR(10),

TYPE VARCHAR(10)

) */

//注册驱动

Class.forName("com.mysql.jdbc.Driver");

//获取数据库连接

String url="jdbc:mysql://localhost:3306/cgb2107?characterencoding=utf8";

Connection con = DriverManager.getConnection(url,"root","root");

//获取传输器

String sql = "insert into car values(null,?,?,?,?)";

PreparedStatement p = con.prepareStatement(sql);

//给SQL设置参数---参数的顺序一定要和字段的顺序一致

p.setObject(1,c.getColor());

p.setObject(2,c.getPrice());

p.setObject(3,c.getPinpai());

p.setObject(4,c.getType());

//执行SQL

p.executeUpdate();

//释放资源

p.close(); con.close();

//{"id":1,"color":"red","price":100.0,"pinpai":"BMW","type":"X7"}

return c;

}

前端代码

<!DOCTYPE html>

<html>

<head>

<title>前后端整合</title>

</head>

<body>

普通的get提交方式</a>

<a href="http://localhost:8080/user/insert2/10/rose/20">restful方式</a>

<a href="http://localhost:8080/car/save3?

id=1&color=red&price=100&pinpai=BMW&type=X7">点我获取汽车数据 </a>

<a href="http://localhost:8080/car/save3?

id=1&color=red&price=100&pinpai=BMW&type=X7">点我保存汽车数据</a>

</body>

</html>

测试

启动服务器后 ,打开浏览器测试

总结

SpringMVC框架解析post提交的请求参数

项目结构

准备表单

<!DOCTYPE html>

<html>

<head>

<style>

body{

font-size: 17px; /* 字号 */

background-color: lightpink; /* 背景色 */

}

/* 输入框 */

.a{

width: 300px; /* 宽度*/

height: 40px; /* 高度 */

font-size: 20px; /* 字号 */

}

/* 保存按钮 */

input[type="submit"]{

/* 背景色字的颜色边框颜色宽度高度 */

background-color: #0000FF;

border-color: #0000FF;

color: white;

width: 100px;

height: 40px;

font-size: 20px; /* 字号 */

}

/* 取消按钮 */

input[type="button"]{

/* 背景色字的颜色边框颜色宽度高度 */

background-color: #FF69B4;

border-color: #FF69B4;

color: white;

width: 100px;

height: 40px;

font-size: 20px; /* 字号 */

}

</style>

</head>

<body>

<!-- 表单可以提交数据,默认get方式.

method="post"指定提交方式,action=""指定跳转的网址

要求:1,必须是form 2,必须有submit按钮 3,必须配置name属性

-->

<table>

<tr>

<td>

<h2>学生信息管理系统MIS</h2>

</td>

</tr>

<tr>

</tr>

<tr>

<td>

<input class="a" type="text" placeholder="请输入姓名"

name="name">

</td>

</tr>

<tr>

</tr>

<tr>

<td>

<input class="a" type="number" placeholder="请输入年龄"

name="age">

</td>

</tr>

<tr>

<td>

性别:(单选框)

<input type="radio" name="sex" value="1" checked="checked"/>男

<input type="radio" name="sex" value="0"/>女

</td>

</tr>

<tr>

<td>

爱好:(多选)

<input type="checkbox" name="hobby" value="ppq"

checked="checked"/>乒乓球

<input type="checkbox" name="hobby" value="ps"/>爬山

<input type="checkbox" name="hobby" value="cg"/>唱歌

</td>

</tr>

<tr>

<td>

学历:(下拉框)

</select>

</td>

</tr>

<tr>

<td>

入学日期:

</td>

</tr>

<tr>

<td>

</td>

</tr>

</table>

</form>

</body>

</html>

准备启动类

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);

}

准备Controller类，解析请求数据

package cn.tedu.controller;

import cn.tedu.pojo.Student;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

//和浏览器交互,接受请求,给出响应

@RestController

@RequestMapping("student")

public class StudentController {

//解析请求参数

@RequestMapping("save")

// public String save(String name,Integer age,String sex,String hobby){

public String save(Student s){

//Student{name='jack', age=20, sex=0,

hobby=[ppq, ps, cg], edu=2, intime=Wed Sep 15 00:00:00 CST 2021}

System.out.println(s);

return "保存成功!" ;

}

创建Student类，用来封装数据

package cn.tedu.pojo;

import java.util.Arrays;

import java.util.Date;

//充当了MVC的M层,model层,用来封装数据

//pojo类里只有属性和set() get()

public class Student {

//规则: 属性的类型属性的名字

//和HTML页面保持一致:参考页面输入的值参考页面中name属性的值

private String name;//用来封装用户在浏览器输入的用户名

private Integer age;//用来封装用户在浏览器输入的年龄

private Integer sex;//用来封装用户在浏览器选择的性别

private String[] hobby;

//用来封装用户在浏览器选择的爱好--多选的结果存入数组

private Integer edu;

//400异常的原因:页面上输入的日期是String类型

//String->Date: @DateTimeFormat,需要指定日期的格式y是年M是月d是天

@DateTimeFormat(pattern="yyyy-MM-dd")

private Date intime;//用来封装用户在浏览器选择的日期

//get set tostring

public String getName() {

return name;

}

@Override

public String toString() {

return "Student{" +

"name='" + name + '\'' +

", age=" + age +

", sex=" + sex +

", hobby=" + Arrays.toString(hobby) +

", edu=" + edu +

", intime=" + intime +

'}';

}

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;

}

测试

扩展：入库

修改pom，添加jdbc的jar包

（1）直接在最外面的pom里加就行了，里面的每个module都可以用

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

创建数据库表

CREATE TABLE student(

id INT PRIMARY KEY AUTO_INCREMENT,

NAME VARCHAR(20),

age INT,

sex INT,

hobby VARCHAR(100),

edu INT,

intime DATE

)

创建StudentController类，接受请求，包括入库

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;

//和浏览器交互,接受请求,给出响应

@RestController

@RequestMapping("student")

public class StudentController {

//解析请求参数

@RequestMapping("save")

// public String save(String name,Integer age,String sex,String hobby){

public String save(Student s) throws Exception {

//TODO 把解析成功的学生数据入库

//1,修改pom添加jar包(直接改了project里的pom.xml)

//2,建表student

CREATE TABLE student(

id INT PRIMARY KEY AUTO_INCREMENT,

NAME VARCHAR(20),

age INT,

sex INT,

hobby VARCHAR(100),

edu INT,

intime DATE

)

//3,写jdbc

//注册驱动

Class.forName("com.mysql.jdbc.Driver");

//获取数据库连接

String url="jdbc:mysql://localhost:3306/cgb2107?characterencoding=utf8";

Connection con = DriverManager.getConnection(url,"root","root");

//获取传输器--插入的值的个数参考字段的个数,

顺序也是参考字段的顺序

String sql="insert into student values(null,?,?,?,?,?,?)";

PreparedStatement p = con.prepareStatement(sql);

//设置SQL的参数

p.setObject(1,s.getName());

p.setObject(2,s.getAge());

p.setObject(3,s.getSex());

//注意:数据库里根本没有数组的类型,需要String[]->String,

否则Data too long for column 'hobby' at row 1

p.setObject(4, Arrays.toString(s.getHobby()) );

p.setObject(5,s.getEdu());

p.setObject(6,s.getIntime());

//执行SQL

p.executeUpdate();

//释放资源

p.close(); con.close();

return "保存成功!" ;

}

总结

扩展：修改Tomcat端口号

Spring框架

概述

Spring框架重点提供的: IOC DI AOP
IOC : 控制翻转, 是指把创建对象的权利交给spring.
DI : 依赖注入, 是指把有依赖关系的对象也同时new出来.
AOP : 面向切面编程, 补充了OOP不足

IOC的使用

创建类

package cn.tedu.spring;

public class Hello {

public void hi(){

System.out.println("hello springioc~");

}

创建配置文件，配置类的信息

<?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">

<!-- spring认为万物皆是bean,配置bean的位置,spring自动完成ioc

class属性用来描述类的全路径, id属性用来作为bean的唯一标识

-->

</beans>

IOC的xml方式 - 了解

项目结构

创建Hello类

package cn.tedu.spring;

public class Hello {

public void hi(){

System.out.println("hello springioc~");

}

创建User

package cn.tedu.spring;

public class User {

public void eat(){

System.out.println(123);

}

创建配置文件

<?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">

<!--spring认为万物皆是bean,配置bean的位置,spring自动完成ioc

class属性用来描述类的全路径, id属性用来作为bean的唯一标

识

scope="prototype"用来设置对象是多例的,默认是singleton单例

的

IOC底层是Map结构,Map<id的值,类的对象>,数据结类似: {"hello",new Hello()}

spring只能用反射创建对象:

{"hello",Class.forName("cn.tedu.spring.Hello").newInstance() }

-->

</beans>

创建测试类

package cn.tedu.spring;

import org.junit.jupiter.api.Test;

import org.springframework.

context.support.ClassPathXmlApplicationContext;

public class Test1 {

//测试IOC(创建类+配置类)

@Test//junit单元测试方法:@Test void public 没有参数

public void ioc(){

//1,读取配置文件--参数是配置文件的路径

ClassPathXmlApplicationContext spring =

new ClassPathXmlApplicationContext(

"spring-config.xml");

//2,获取spring创建好的对象--参数是配置文件里bean标签的id

的值

Object o = spring.getBean("hello");

System.out.println(o);//cn.tedu.spring.Hello@43bc63a3

Hello h = (Hello) o;

h.hi();

//单例对象:节省内存和时间,spring框架默认的创建单例对象的

方式

Hello h2 = (Hello) spring.getBean("hello");

// System.out.println(o2);//cn.tedu.spring.Hello@43bc63a3

h2.hi();

//java.lang.ClassCastException:cn.tedu.spring.Hello cannot be cast to cn.tedu.spring.User

//User uu = (User) spring.getBean("hello");

//System.out.println(uu);

Object o3 = spring.getBean("user");

System.out.println(o3);//cn.tedu.spring.User@38425407

//向下转型:把父类类型变成子类类型,目的要用子类的功能

User u = (User) o3 ;

u.eat();

}

IOC的注解方式 - 重点

（1）创建类, 类上使用IOC的注解

（2）创建配置文件, 指定包扫描的路径

（3）直接getBean(“类名首字母要变成小写”)

pring认为万物皆是bean,配置bean的位置,spring自动完成ioc

class属性用来描述类的全路径, id属性用来作为bean的唯一标识

scope="prototype"用来设置对象是多例的,默认是singleton单例的

IOC底层是Map结构,Map<id的值,类的对象>,数据结类似: {"hello",new Hello()}

spring只能用反射创建对象:

{"hello",Class.forName("cn.tedu.spring.Hello").newInstance() }

项目结构

创建类

package cn.tedu.spring;

import org.springframework.stereotype.Component;

@Component //用来让spring完成ioc {"person"=new Person()}

public class Student {

public void study(){

System.out.println("Student.study()");

}

package cn.tedu.spring;

import org.springframework.stereotype.Component;

@Component //用来让spring完成ioc {"person"=new Person()}

public class Person {

public void show(){

System.out.println("Person.show()");

}

配置包扫描

<?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">

<!--包扫描:扫描指定包以及子包里的所有资源,找到有IOC注解的类就进行new

IOC的注解包括: @Component @Service @Controller

base-package 用来指定包路径,范围越小越好,性能高

-->

<context:component-scan base-package="cn.tedu"></context:component-scan>

</beans>

测试

package cn.tedu.spring;

import org.junit.jupiter.api.Test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {

//单元测试方法

@Test

public void ioc(){

//1,读取配置文件---参数是配置文件的路径

ClassPathXmlApplicationContext spring =

new ClassPathXmlApplicationContext(

"spring.xml");

//2,getBean()---参数是类名,首字母小写

Object o = spring.getBean("person");

System.out.println(o);

//cn.tedu.spring.Person@7e5afaa6

Object o1 = spring.getBean("student");

System.out.println(o1);

Object o2 = spring.getBean("animal");

System.out.println(o2);

}

模拟DI依赖性

概述

维护了两个对象间的关系，方便在使用A的同时可以看到关联的B的数据

测试

创建Emp类

package cn.tedu.di;

public class Emp {

String name = "吴谦";

//绑定了两个类的关系--依赖

private Dept d;

//get set

public Dept getD() {

return d;

}

public void setD(Dept d) {

this.d = d;

}

@Override

public String toString() {

return "Emp{" +

"name='" + name + '\'' +

", d=" + d +

'}';

}

创建Dept类

package cn.tedu.di;

public class Dept {

String name = "java软件开发一部";

@Override

public String toString() {

return "Dept{" +

"name='" + name + '\'' +

'}';

}

创建测试类

package cn.tedu.di;

import org.junit.Test;

public class TestDi {

@Test

public void di(){

//1,创建对象

Emp e = new Emp();

Dept d = new Dept();

//Emp{name='吴谦', d=null}

System.out.println(e);

//2,di维护了两个对象间的关系-set()

e.setD(d);

//Emp{name='吴谦', d=Dept{name='java软件开发一部'}}

System.out.println(e);

}

Spring提供的ID依赖注入

创建UserInfo

package cn.tedu.di2;

import org.springframework.stereotype.Component;

@Component//ioc -- {"userInfo"=new UserInfo()}

public class UserInfo {

String name="jack";

@Override

public String toString() {

return "UserInfo{" +

"name='" + name + '\'' +

'}';

}

创建Order类

package cn.tedu.di2;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

@Component//ioc--{"order"=new Order()}

public class Order {

String name = "iphone13";

//get set

@Autowired //di

private UserInfo ui;

@Override

public String toString() {

return "Order{" +

"name='" + name + '\'' +

", ui=" + ui +

'}';

}

测试

package cn.tedu.di2;

import org.junit.Test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDI {

@Test

public void di(){

//1,读取配置文件

ClassPathXmlApplicationContext spring =

new ClassPathXmlApplicationContext(

"spring.xml");

//2,getBean()--DI:获取A的同时也获取到B的信息

Object o = spring.getBean("order");

//Order{name='iphone13',ui=UserInfo{name='jack'}}

System.out.println(o);

}

总结

IOC: 控制翻转,Spring框架创建对象.
使用步骤: 1, 在类上使用注解@Component @Service @Controller 2, 配置包扫描
DI: 依赖注入,把两个对象之间的关系依赖.
使用步骤: 1, 先完成IOC 2, 用注解@Autowired

扩展：SpringMVC源码里的核心方法

SpringAOP

概述

是面向切面编程,扩展了面向对象的不足.
切面Aspect: 其实就是一个类, 要用@Aspect注解
通知Advice: 就是类里的方法, 分为:前置通知后置通知环绕通知返回后通知异常通知
切点Pointcut: 就是定义了方法的触发时间,切入点表达式

使用步骤

加入jar包

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-aop</artifactId>

</dependency>

</dependencies>

创建切面

package cn.tedu.service;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.*;

import org.springframework.stereotype.Component;

@Component

@Aspect //切面:通知 + 切点

public class Timer {

//2,切点表达式,通过execution属性声明

//* cn.tedu.service.*.*(..) 方法返回值包名.类名.方法名(参数列表)

@Pointcut("execution(* cn.tedu.controller.*.*(..))")

public void pointcut(){}

//1,通知:分类: 前置通知后置通知环绕通知返回后通知异常通知

//前置通知:在调用你的目标方法前,就要执行

@Before("pointcut()")

public void beforeMethod(JoinPoint joinPoint){

System.out.println("我是前置通知~~~~~");

//常见的使用场景:权限缓存开启事务日志

}

//后置通知:在调用你的目标方法后,就要执行

@After("pointcut()")

public void afterMethod(JoinPoint joinPoint){

System.out.println("我是后置通知~~~~~");

//常见的使用场景:结束事务日志释放资源

}

//环绕通知:在调用你的目标方法之前和之后,都要执行

@Around("pointcut()")

public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {

long start = System.currentTimeMillis();//计时开始

Object o = joinPoint.proceed();//继续执行你的目标方法

long end = System.currentTimeMillis();//计时结束

System.out.println("aop统计的总耗时是:"+(end-start));

return o;//放回给调用者,继续执行方法

}

测试

创建启动类

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);

}

创建HelloController类

package cn.tedu.controller;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

@RestController//Controller + ResponseBody

@RequestMapping("hello")

public class HelloController {

@RequestMapping("hello")

public String hello(){

for (int i = 0; i <100 ; i++) {

System.out.println("=");

}

return "恭喜您,访问成功~";

}

//统计hello()方法的性能

//缺点:目前只能统计hello()方法的性能,想要统计其他方法的性能--AOP

//AOP思想好处:让程序员更加关注业务本身,把通用的代码形成切面

@RequestMapping("hello2")

public String hello2(){

long start = System.currentTimeMillis();

hello();

long end = System.currentTimeMillis();

return "访问时间:"+(end-start) ;

}

测试

访问HelloController 里的每个方法,都会执行对应的通知

两个框架的整合

需求

获取汽车数据

开发结构

项目结构

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);

}

application.yml改端口

server:

port: 8090

Car类，封装数据

package cn.tedu.pojo;

import org.springframework.stereotype.Component;

//模型层,用来封装数据

@Component//交给spring框架进行ioc

public class Car {

private Integer id;

private String name;

private String color;

private Double price;

//get set tostring

@Override

public String toString() {

return "Car{" +

"id=" + id +

", name='" + name + '\'' +

", color='" + color + '\'' +

", price=" + price +

'}';

}

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;

}

CarService接口，定义抽象方法

package cn.tedu.service;

import cn.tedu.pojo.Car;

import java.util.List;

//接口里都是抽象方法

//jdk1.8也可以有static或者default的普通方法

public interface CarService {

//简写形式,public abstract

List<Car> get();//获取Car数据

}

CarServiceImpl实现类，重写抽象

package cn.tedu.service;

import cn.tedu.pojo.Car;

import org.springframework.stereotype.Component;

import org.springframework.stereotype.Service;

import java.util.ArrayList;

import java.util.List;

//实现类实现了接口要重写抽象方法,否则就是一个抽象类

@Service//和Component一样,都可以完成ioc,只是更好的表示了是service层的代码

public class CarServiceImpl implements CarService{

//重写的要求:方法声明和父类一样,有权限

public List<Car> get(){

Car c1 = new Car();//空对象,属性都是默认值null

c1.setId(10);c1.setName("bmw");c1.setColor("red");

c1.setPrice(9.9);

Car c2 = new Car();//空对象,属性都是默认值null

c2.setId(20);c2.setName("audi");c2.setColor("black");c2.setPrice(6.6);

List<Car> list = new ArrayList<>();

list.add(c1);

list.add(c2);

return list;//给调用者返回list数据

}

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

@RequestMapping("car")

public class CarController {

//1,调用CarServiceImpl里准备好的汽车数据--DI

@Autowired

private CarService carService;

//2,提供方法,给浏览器返回汽车数据

@RequestMapping("get")

public List<Car> get(){

//调用service的功能,service会把结果返回来

return carService.get() ;

}

测试

总结

改造前端代码

使用axios语法发起请求

<!DOCTYPE html>

<html>

<head>

<title>前后端整合起来</title>

</head>

<body>

点我获取汽车数据</button>

</div>

new Vue({

el : "#app" , //挂载点

methods : { //定义函数

get(){

//使用axios技术,访问后端服务器

axios.get("http://localhost:8090/car/get").then(

//a是服务器的返回值交给a变量保存箭头函数

//data属性用来获取数据, a.data就是获取a的数据

a => { console.log(a.data) }

)

}

})

</script>

</body>

</html>

修改后端服务器的Controller，加一个特殊的注解，@CrossOrigin

package cn.tedu.controller;

import cn.tedu.pojo.Car;

import cn.tedu.service.CarService;

import cn.tedu.service.CarServiceImpl;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.CrossOrigin;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController

@RequestMapping("car")

@CrossOrigin//放行js的访问请求

public class CarController {

@Autowired

private CarService carService;

@RequestMapping("get")

public List<Car> get(){

return carService.get() ;

}

Vue路由

测试

<!DOCTYPE html>

<html>

<head>

<title>测试 vue路由</title>

</head>

<body>

<!-- 4.使用路由 router-link被HTML翻译

成a标签,to属性被翻译成href属性-->

<router-link to="/test1">点我显示主页

</router-link>

<router-link to="/test2">点我显示帮助页

</router-link>

<router-view></router-view>

</div>

//3.3.定义组件

var home = { template : "<h1>我是主页

</h1>" }

var help = { template : "<h1>我是帮助页

</h1>" }

//3.2.创建路由实例

var luyou = new VueRouter({

routes : [

//属性用来定义路由规则

//规定哪个路径匹配哪个名字的组件

{ path:"/test1" , component:home },

{ path:"/test2" , component:help }

]

})

new Vue({

el : "#app", //挂载点

router : luyou

//3.1.通过router属性配置路由

})

</script>

</body>

</html>

总结