SpringMVC、Spring

Maven

Maven是跨平台的项目管理工具。主要服务于基于java平台的项目构建、依赖管理和项目信息管理。

Java工程中我们自己去找jar，或者来自官网，或者来自网友的分享，或者来自项目团队的共享，不论何种方式，都需要把jar文件复制到lib目录中，并且buildpath。

四大特征

仓库 repository

• 全球仓库，称为中央仓库，全球开发者都可以连接它来自动下载jar包
• 全球各地做镜像仓库，如中国就有网易、阿里等镜像仓库
• 本地仓库。下载一次后，不会再次下载的，除非你删除了。

当用户需要某个jar包时，先到本地仓库寻找，没有再去镜像仓库，没有再去中央仓库。中央仓库找到后，并不直接返回到本地仓库，而是保存一份到镜像仓库，镜像仓库返回本地仓库，本地仓库也保存一份，然后返回给调用者。这样设计是不是太精妙了，只需维护中央仓库，其它仓库自行维护。

依赖 dependency

每个核心jar包形成一个依赖，maven底层进行它相关的jar的自动导入

A jar包可能依赖很多jar包，maven自动管理

坐标 coordinate

<dependency>		//依赖
	<groupId>mysql</groupId>		//坐标，包结构
	<artifactId>mysql-connector-java</artifactId>	//项目名
	<version>5.1.32</version>		//版本号
</dependency>

E:\Java\Maven\repository\mysql\mysql-connector-java\5.1.48

命令 mvn cmd

共有3个生命周期：clean、default、site，每个生命周期包含多个阶段phase。

• clean 清理
• compile 编译
• test 测试
• site 站点文档
• package 打包jar、war
• deploy 部署到私服
• install 安装jar到本地仓库中
• run 运行

SpringBoot

• SpringBoot就是maven的延伸
• SpringBoot全新的pom.xml：覆盖了Maven的pom.xml
• SpringBoot默认集成了tomcat中间件，会自动把项目打包jar发布到tomcat，这样我们就形成了自己的网站。但这个网站只能局域网访问，如果外网（广域网），自己购买一个网站，部署上去即可。

pom.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>cn.tedu</groupId>
	<artifactId>jk</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>jk</name>
	<description>Demo project for Spring Boot</description>

  	<!-- 提供相关的 Maven 默认依赖 -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<properties>
		<!-- 使用jdk8 -->
		<java.version>1.8</java.version>
	</properties>
	
	<!-- 添加依赖 -->
	<dependencies>
		<!-- 使用springmvc构建程序并使用默认的嵌入式容器Tomcat -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		
		<!-- 使用Junit测试springboot程序 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		
	</dependencies>

	<build>
		<!-- 添加插件 -->
		<plugins>
			<!-- springboot添加maven插件,会打包成一个可以直接运行的 JAR 文件,直接部署到服务器 -->
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

@RestController                     //springmvc提供，让浏览器访问类
@RequestMapping("hi")    //请求映射，mvc提供，规定访问方式，可在类、方法上
public class HelloBoot {        
    @RequestMapping("abc")
    public String hello(){
        return "Hellow Spring Boot...";
    }
}
//访问地址：http://localhost:8082/hi/abc   区分大小写
//localhost代表本机，等价于ip：127.0.0.1

SpringMVC

MVC设计模式中认为, 任何软件都可以分三层：控制层（Controller）、数据处理模型（Model）、负责展示数据的视图（View），将软件进行分层达到松耦合的效果。

M：模型层，用来封装数据

V：视图层，用来展示数据

C：控制层，用来接受请求、给出响应

POJO就是Model层，JSP就是视图层，Controller就是控制层。

SpringMVC主要作用：处理请求参数

五个核心组件

1. 前端控制器 DispatcherServlet
2. 处理器映射 HandlerMapping
3. 处理器适配器 HandlerAdapte
4. 视图解析器 ViewReslover
5. 视图渲染 View

配置

连接数据库

   <!--pom.xml文件-->
   <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>
    </dependencies>

处理Get请求参数

@RestController//接受请求,返回json数据；表示conrtoller层的
//=@Controller+@ResponseBody

/如果页面的名称和后台形参的名称不一致,可以使用@RequestParam(“页面名称”),就必须指定值.

@RequestMapping("car")
public class CarController {

		//访问 http://localhost:8080/car/add?id=10,必须设置id的值否则报错,?拼接是固定语法
	@RequestMapping("add")
	public void add(int id) {		//参数名必须为id
		System.out.println("数据添加成功,id="+id);
	}
    
		//访问 http://localhost:8080/car/save?id=90&name=tony ,设置多个参数值时用&连接
	@RequestMapping("save")
	public void save(int id,String name) {
		System.out.println("数据保存成功,id="+id+",name="+name);
	}
}

/*访问方式@RequestMapping("save")的参数不能重复*/

使用引用类型参数可不赋值，默认值为null，不报异常

    @RequestMapping("save")
    public void add(Integer id, String color,Double price){
        System.out.println("id="+id+" color="+color+" price="+price);
    }

参数设置为对象，框架自动调用类的set()方法将获取的值存入对象中

@RequestMapping("save")
public void add(Car c){
	System.out.println(c);
}

public class Car{
    private Integer id;
   
//必须加get、set方法，不然不会存值
    public Integer getId() {
        return id;				//请求参数必须与属性名一致
    }

    public void setId(Integer id) {
        this.id = id;
    }
}

/*
*访问 http://localhost:8082/car/save?id=100&name=BMW&color=red
*框架自动获取数据，参数为对象访问与get一样
*/

restful

    @RequestMapping("insert/{id}/{name}/{age}")		
    public void insert(
            @PathVariable Integer id,
            @PathVariable String name,
            @PathVariable Integer age) {
        System.out.println("id="+id+" name="+name+" age="+age);
    }

post请求参数

<form method="post" action="http://localhost:8083/student/save">

服务器端与get一样

项目结构

POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans，是为了避免和EJB混淆所创造的简称。

启动类

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类

@RestController
@RequestMapping("student")
public class StudentController {

    @RequestMapping("save")
    public String save(Student s){
   //将数据存入数据库
        Class.forName("com.mysql.jdbc.Driver");
        String url = "jdbc:mysql://localhost:3306/MVC";
        Connection c = DriverManager.getConnection(url, "root", "root");

        String sql = "insert into student values(null ,?,?,?,?,?,?)";
        PreparedStatement ps = c.prepareStatement(sql);
        
        ps.setObject(1,s.getName());
        ps.setObject(2,s.getAge());
        ps.setObject(3,s.getSex());
        ps.setObject(4, Arrays.toString(s.getHobby()));	//数据库不能保存数据，转为字符串
        ps.setObject(5,s.getEdu());
        ps.setObject(6,s.getIntime());

        ps.executeUpdate();
  
        ps.close();
        c.close();
  
        return "保存成功！";
    }

}

pojo类

public class Student {
    private String name;  //必须与HTML中name="name"的"name"一致,类型与valuez类型一致
    private Integer age;
    private Integer sex;
    private String[] hobby;	//checkbox多选框传入数组
    private Integer edu;

    @DateTimeFormat(pattern = "yyyy-MM-dd")     //表示年(y)月(M)日(d)格式
    private Date intime;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

开箱即用

resources下的application.yml文件

application.properties优先级高于application.yml（覆盖结果）

#springboot的特殊文件，将被springboot自动加载
#格式 k: v
#修改Tomcat端口号，默认端口8080,0~65535个端口号，0~1024被系统占用
server:
  port: 8888

流程：

1. 表单中get、post提交数据

   不限定：
   @RequestMapping
   
   限定get：
   @RequestMapping(value = "save",method = RequestMethod.GET)
   @GetMapping
   
   限定post：
   @RequestMapping(value = "save",method = RequestMethod.POST)
   @PostMapping
   

2. 根据路径和@RequestMapping找到方法

3. mvc解析数据、将数据存入对象（参数）中

4. 连接数据库，获取传送器，将对象的数据取出、存入

注解

• @RestController = @Controller + @ResponseBody

  @Controller:Spring提供

  @ResponseBody:Springmvc提供

Spring

@controller new对象

• IoC（Inversion of Control）控制反转：简单来说就是将对象Object的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理，而是在需要的时候由Spring框架提供。

• DI（Dependency Injection）依赖注入：在创建对象的过程中Spring可以依据对象的关系，自动把其它对象注入（无需创建对象，直接拿着使用）进来。

• AOP面向切面编程：补充java面向对象的不足

IOC

1、配置文件

resource中的xml文件配置bean

<?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自动完成ioc

    class描述类的全路径（右键copy reference获取全路径）,id作bean的唯一标识

    scope="prototype"属性改为多例对象

    IOC是Map<id的值，类的对象>  {"hello",new Hello()}
    实际存：{"hello",Class.forName(spring.Hello).newInstance()}
    -->
    <bean class="spring.Hello" id="hello" ></bean>

</beans>

2、创建bean对象

public class Test1 {

    @Test
    public void ioc(){
        //读取配置文件，参数是配置文件的路径
        ClassPathXmlApplicationContext sp =
                new ClassPathXmlApplicationContext("spring-config.xml");
        //获取spring创建好的对象，参数是id值
        Object o = sp.getBean("hello");
        //返回单例的对象o，节省内存和时间，spring框架默认创建方式
        Hello h = (Hello) o;	//向下转型：父变子
        h.hi();
    }

}
//classCastException：类转换异常

注解

配置包扫描

 <!--src中的xml文件，包扫描，只会扫描配置的包，扫描此包所有资源，找到有@Component注解
component组件;scan扫描
-->
<context:component-scan base-package="cn.tedu.spring"></context:component-scan>

自动包扫描

@SpringBootApplication		//注解自动扫描本类同级的包
public class RunApp {
    public static void main(String[] args) {
        SpringApplication.run(RunApp.class);
    }
}

类注解

@Component      //用来帮spring完成ioc，
public class Person {
    public void show(){
        System.out.println("Person.show()");
    }
}

创建bean对象

public class Test1 {
    @Test
    public void ioc(){
        //读取配置文件
        ClassPathXmlApplicationContext s =
                new ClassPathXmlApplicationContext("spr.xml");
        //getBean();参数是类名，首字母变小写
        Object o = s.getBean("person");
        System.out.println(o);
    }

}

重命名bean名字

@Component(value = “p1”) //value可被省略

有两个同名类都在bean池时，会报错，必须重命名

总结

• 读取配置文件时，读取指定包中有@Component注解的类，这时在Spring容器中创建所有有此注解的bean对象。或创建所有配置文件中写的对象。

  • 可通过在xml中设置属性 lazy-init=“true” ，到getBean()时才创建，而非读取配置文件时就创建bean

• getBean()方法将bean对象根据 id值 或 默认创建bean名称（类名+首字母小写）获取bean对象

ioc两种方式

• xml方式
  1. 在xml中配置bean：
  2. 读取配置文件：ClassPathXmlApplicationContext(“spring-config.xml”)
  3. 获取bean：getBean(“hello”)
• 注解方式
  1. 创建类，在类上使用注解@Component
  2. 在xml中配置要扫描的包路径：<context:component-scan base-package=“cn.tedu.spring”>
  3. 读取配置文件：ClassPathXmlApplicationContext("")
  4. 获取bean：getBean(“hello”) 参数默认为类名首字母小写

DI

前提：两个关联类都完成ioc

使用：在一个类中需要使用关联类的属性、方法

两个关联的类

@Component	//ioc创建对象
public class UserInfo {
    String name = "jack";
}

@Component
public class Order {
    String name = "iphone13";

    @Autowired      //DI，不用new UserInfo()对象
    private UserInfo ui;
    // setUserInfo(new UserInfo());本类不用set也可用UserInfo的属性、方法
}

创建有关联类的对象

public void di(){
        ClassPathXmlApplicationContext s =
                new ClassPathXmlApplicationContext("spr.xml");
        Object o = s.getBean("order");
}
//输出：Order{name='iphone13', ui=UserInfo{name='jack'}}

AOP

面向切面编程AOP（Aspect Oriented Programming）

@Component
@Aspect     //切面
public class AspectD {
    //*：方法返回值     cn.tedu.service：包名
    // *：类名      *：方法名       （..）：参数列表
    //*表示所有     ..表示可变
    @Pointcut("execution(* cn.tedu.controller.*.*(..))")
    public void pointcut(){}

    //前置通知使用场景：权限、缓存、开启事务、日志
    @Before("pointcut()")
    public void beforMethod(JoinPoint joinPoint){
        System.out.println("我是前置通知");
    }

    //后置通知使用场景：结束事务、日志、释放资源
    @After("pointcut()")
    public void afterMethod(JoinPoint joinPoint){
        System.out.println("我是后置通知");
    }

    @Around("pointcut()")
    public Object doArround(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object o = joinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println("耗时："+(end-start));
        return o;
    }

}

总结

目录：

1. controller：CarController
2. pojo：Car
3. service：CarService、CarServiceImpl
4. RunApp

CarServer接口有多个实现类：

//@Service注解包含@Component，可被bean
@Service("menuService1")
public class MenuServiceImpl implements IMenuService
 
@Service("menuService2")
public class MenuServiceImpl implements IMenuService
 
    @Autowired
    @Qualifier("menuService1")
    private IMenuService menuService;
     
    @Autowired
    @Qualifier("menuService2")
    private IMenuService menuService;

vue中Ajax

	<script type="text/javascript">
		new Vue({
			el:"#app",
			methods:{
				get(){
					axios.get("http://localhost:8084/A/G").then(a=>{
						console.log(a.data);	//服务器的返回值给a保存，箭头函数a.data获取a数据
					})
				}
			}
		})
	</script>

@RestController
@RequestMapping("A")
@CrossOrigin    //放行js的访问请求
public class AnimalController {

    @Autowired
    private AnimalService as;

    //AnimalService a = new AnimalServiceImpl();

    @RequestMapping("G")
    public List<Animal> get(){
        return as.get();
    }
}

路由

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>测试 vue路由</title>
		<script src="vue.js"></script>
		<script src="vue-router.js"></script>
	</head>
	<body>
		
		<div id="app">		
		<!--使用路由-->
		<router-link to="/test1">点我显示主页</router-link>
		<router-link to="/test2">点我显示帮助页</router-link>
				
		<!--展示组件效果-->
		<router-view></router-view>
		</div>
	
		<script type="text/javascript">
			
			//定义组件
			var home={template:"<h1>主页</h1>"};
			var help={template:"<h1>我是帮助页</h1>"};
			
			//创建路由实例
			var luyou = new VueRouter({						
				routes:[		//属性定义路由规则，规定那个组件匹配那个名字的组件
					{path:"/test1",component:home},
					{path:"/test2",component:help}
				]
			});
			
			new Vue({
				el:"#app",
				router:luyou		//router属性配置路由
			})
		</script>
		
	</body>
</html>