目录
一，MVC项目
--1，项目结构图
--2，写前端网页(在HBuilder里)
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>实现MVC的结构</title>
</head>
<body>
<a href="http://localhost:8080/car/get">点我提交请求</a>
</body>
</html>
--3，写RunApp
package cn.tedu;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
//初始化了springboot，包括:自动包扫描，
//扫描启动类所在包以及子包下的所有使用了注解的类，自动ioc
public class RunApp {
public static void main(String[] args) {
SpringApplication.run(RunApp.class);
}
}
--4，写Car类
package cn.tedu.pojo;
import org.springframework.stereotype.Component;
//POJO 类，充当了MVC里的M，用来封装数据
@Component //spring的注解，用来ioc(new)
public class Car {
private String name ;
private String color ;
private Double price ;//用引用类型，避免springmvc请求时抛出异常
//get set toString
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Double getPrice() {
return price;
}
public void setPrice(Double price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", color='" + color + '\'' +
", price=" + price +
'}';
}
}
--5，创建CarService 接口
package cn.tedu.service;
import cn.tedu.pojo.Car;
//接口里都是抽象方法
public interface CarService {
//获取汽车数据
// public abstract Car get();
Car get();
}
--6，创建CarServiceImpl实现类
package cn.tedu.service;
import cn.tedu.pojo.Car;
import org.springframework.stereotype.Component;
//实现类实现了接口，要重写所有 抽象方法
@Component //交给spring容器进行ioc
public class CarServiceImpl implements CarService{
//重写的要求：子类的方法声明必须和父类一样 + 要有足够的权限
@Override
public Car get(){
Car c = new Car();
c.setName("保时捷");
c.setColor("红色");
c.setPrice(641000.0);
return c;//准备要返回的数据，谁调用给谁返回
}
}
--7，创建CarController 类
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.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
//接受请求，处理响应
@RestController
@RequestMapping("car")
public class CarController {
@Autowired//spring di 依赖注入的关系、自动装配，为了用service的功能
private CarService carService;
@RequestMapping("get")
public Car get(){
//业务都放在service层了，直接调用service就行了
return carService.get();
}
}
--8，测试
二，练习MVC结构
--1，需求：
把请求参数，保存并打印
--2，修改HTML文件，新增按钮
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>实现MVC的结构</title>
</head>
<body>
<a href="http://localhost:8080/car/get">点我提交请求</a><br />
<a href="http://localhost:8080/car/add?name=BMW&price=9.9&color=red">点我提交请求</a>
</body>
</html>
--3，修改CarService接口，添加抽象方法
void add(Car c);//新增数据
--4，修改CarServiceImpl类，重写抽象方法
//重写的要求：子类的方法声明必须和父类一样 + 要有足够的权限
@Override//新增数据
public void add(Car c) {
//TODO 发起jdbc，把数据入库
System.out.println(c);
}--5，修改CarController类，添加add方法
//接受请求，解析请求参数
@RequestMapping("add")
public void add(Car c){
//调用service，并给service传递过去请求参数
carService.add(c);
}--6，测试
三，AOP
--1，作用
在方法执行前后加功能。
--2，组成
切面Aspect：其实就是一个类，由通知和切点组成
切点PointCut：找到指定包里的类，类里的方法，增加功能
通知Advice：就是类里的一个方法，分为前置通知(方法执行前要加的)，后置通知(方法执行后要加的)，环绕通知(方法执行前后都要加的)，返回后通知，异常通知
--3，需求
统计所有service层的方法的执行时间
--4，pom.xml里添加jar包
<dependencies>
<!--添加aop依赖包-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
</dependencies>--5，创建切面
package cn.tedu.service;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
//spring的aop功能，其实就是为了增强方法的功能，由切点和通知组成
//aop的使用场景：事务管理，缓存管理，权限管理，日志管理，性能测试
@Component
@Aspect//1. 标记是一个切面
public class AspectTest {
//2. 切点表达式：用来给 指定包，类，方法 加功能
//*代表一个值 ..表示多个值 第1个*表示方法的返回值 第2个*表示类 第2个*表示方法
//@Pointcut("execution(返回值 包名.类名.方法名(参数列表) )")
@Pointcut("execution(* cn.tedu.service..*.*(..) )")
public void point(){}
//3. 通知：本质就是一个方法，增强功能
@Around("point()")//标志这是环绕通知，是在方法执行前后都加了功能
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 ; //返回这个结果
}
}
--6，测试
只要访问了切点规定的包里的资源，都会触发aop统计耗时
四，Mybatis
--1，需求
利用jdbc从数据库中获取name=bmw数据，并给Car设置值
--2，准备Car表
CREATE TABLE `car` (
`name` varchar(255) default NULL,
`color` varchar(255) default NULL,
`price` double default NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
--3，创建测试类
package cn.tedu.service;
import cn.tedu.pojo.Car;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
//利用jdbc从数据库中获取name=bmw数据，把查到的结果设置给car的属性
//先导包
// <dependency>
// <groupId>mysql</groupId>
// <artifactId>mysql-connector-java</artifactId>
// <version>5.1.48</version>
// </dependency>
public class TestJDBC {
public static void main(String[] args) throws Exception {
//1,注册驱动
Class.forName("com.mysql.jdbc.Driver");
//2,获取数据库的连接
String url = "jdbc:mysql:///cgb2104?characterEncoding=utf8&serverTimezone=Asia/Shanghai" ;
Connection conn = DriverManager.getConnection(url,"root","root");
//3,获取传输器
String sql = "select * from car where name = ? " ;
PreparedStatement ps = conn.prepareStatement(sql);
//给SQL设置String类型的参数
ps.setString(1,"bmw");
//4,执行SQL
ResultSet rs = ps.executeQuery();
//5,解析结果集
Car c = new Car(); //5.1
while(rs.next()){ //判断结果集中有数据吗
// rs.getXxx()从结果集中,获取不同类型的数据
String name = rs.getString(1);//获取第1列的值
String color = rs.getString(2);//获取第2列的值
double price = rs.getDouble(3);//获取第3列的值
//!!!! 5.2 拿着从库里查到的数据用一用
c.setName(name);
c.setColor(color);
c.setPrice(price);
}
//5.3 Car{name='BMW', color='red', price=9.9}
System.out.println(c);
//6,释放资源 OOM
rs.close();
ps.close();
conn.close();
}
}
作业：
结合jdbc技术，把CarController接收到的数据入库。
把前后端关联处理业务的代码，CarController和CarService等代码敲三遍。
把AOP代码敲三遍，加强IOC，DI的理解
94
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
