1. DAO设计编码
DAO层（数据访问层）工作：接口设计+SQL编写。
好处：代码和收起来的分离，方便review。
DAO拼接等逻辑在service层完成。
数据库的表设计、DAO的接口（执行sql语句、获取操作结果封装信息、返回操作结果）、
Mybatis如何实现DAO
注：DAO层实现的关键在于得到能与数据库交互、能执行sql语句的对象，mybatis就是提供这样一个对象：SqlSession
SqlSession(即一次与数据库交互的会话)的作用：
1. 向sql语句传入参数
2. 执行sql语句
3. 获取执行sql语句的结果
4. 事务的控制
2. Service设计编码
接口设计以及编码实现、Spring管理Service、在Service方案去标注这个方法是一个事物操作
3. Web设计编码
Restful接口及前端交互
简单绑定是将一个用户界面元素（控件）的属性绑定到一个类型（对象）实例上的某个属性的方法。
// http://localhost:8080/array.do?name=Tom&name=Lucy&name=Jim
//输出：Tom Lucy Jim
@RequestMapping(value = "array.do")
@ResponseBody
public String array(String[] name) {
StringBuilder sbf = new StringBuilder ();
for(String item : name) {
sbf.append(item).append(" ");
}
return sbf.toString();
}
//绑定实体类对象
// http://localhost:8080/object.do?name=Tom&age=10
// 输出：User{ name:'Tom', age:10}
@RequestMapping(value = "object.do")
@ResponseBody
public String object(User user) {
return user.toString();
}
//多层级的数据绑定
// http://localhost:8080/object.do?name=Tom&age=10&contactInfo.phone=10086
//输出：User{name='Tom', age=10, contactInfo=ContactInfo{phone='10086', address='null'}}
//同属性的多对象
// http://localhost:8080/object.do?user.name=Tom&admin.name=Lucy&age=10
//输出：User{name='Tom', age=10, contactInfo=null} Admin{name='Lucy', age=10}
@RequestMapping(value = "object.do")
@ResponseBody
public String object(User user,Admin admin) {
return user.toString()+" "+admin.toString();
}
@InitBinder("user")
public void initUser(WebDataBinder binder) {
binder.setFieldDefaultPrefix("user.");
}
@InitBinder("admin")
public void initAdmin(WebDataBinder binder) {
binder.setFieldDefaultPrefix("admin.");
}
//Map的数据绑定
// http:localhost:8080/map.do?users[x].name=Tom$users[x].age=10
@RequestMapping(value = "map.do")
@ResponseBody
public String map(UserMapForm userMapForm) {
return userMapForm.toString();
}
//Json的数据绑定
{
"name": "jim",
"age": 16,
"userInfo": {
"address": "北京",
"phone": "1000"
}
}
@RequestMapping(value = "json.do")
@ResponseBody
public String json(@RequestBody User user) {
return user.toString();
}
springMVC的强大功能：
注解映射驱动：通过RequestMapping去映射URL，进而绑定到方法上，怎样去传递数据，
甚至是访问cookie的数据，以及怎样决定返回类型是json还是普通的jsp。
ec与idea区别
workspace - project
project - module
idea属性配置：
resources文件下建application.yml
server:
port: 8080
context-path: /girl
cupSize: B
age: 18
//配置中套配置
content: "cupSize: ${cupSize}, age: ${age}"
// htttp:127.0.0.1:8080/girl/hello
@RestController
public class HelloController {
@Value("${cupSize}") // @Value配置内容注入
private String cupSize;
@Value("${age}")
private Integer age;
@Value("${content}")
private String content;
@RequestMapping(value = "/hello", method = RequestmMethod.GET)
public String say() {
return content; 输出： cupSize:B, age:18
//return cupSize + age; 输出B18
//return "Hello Spring Boot!";
}
}
//上面一个一个获取女生的属性太麻烦，需要一个一个的添加注解
application.yml配置：
server:
port； 8080
girl:
cupSize: B
age: 18
//新建实体类GirlProperties
@Component
@ConfigurationProperties(prefix = "girl")
public class GirlProperties {
private String cupSize;
private Integer age;
public String getCupSize() {
return cupSize;
}
public void setCupSize(String cupSize) {
this.cupSize = cupSize;
}
}
//使用
@RestController
public class HelloController {
@Autowired
private GirlProperties girlProperties;
@RequestMapping(value = "/hello", method = RequestmMethod.GET)
//@RequestMapping(value = {"/hello", "/hi"}, method = RequestmMethod.GET) 这样访问/hello或/hi就一样了
public String say() {
return girlProperties.getCupSize();
}
}
@Controller 处理http请求
@RestController Spring4之后新加的注解，原来返回json需要@ResponseBody配合@Controller
@RequestMapping 配置url映射
@PathVariable 获取url中的数据
@RequestParam 获取请求参数的值
@GetMapping 组合注解
例：
@RestController
@RequestMapping("/hello")
public class HelloController {
//@RequestMapping(value = "/say", method = RequestmMethod.GET) 这个太长，可以使用组合注解：@GetMapping
//@GetMapping(value = "/say')
@RequestMapping(value = "/say", method = RequestmMethod.GET)
// http://127.0.0.1:8080/hello/say?id=111
public String say(@RequestParam("id") Integer Id) {
return "id:" + Id;
}
// 可以设置默认值，即使不传参也不会报错
public String say(@RequestParam(value = "id", required = false, defaultValue = "0") Integer Id) {
return "id:" + Id; //不穿参数默认会输出0
}
@RequestMapping(value = "/say/{id}", method = RequestmMethod.GET)
// http://127.0.0.1:8080/hello/say/111
public String say(@PathVariable("id") Integer Id) {
return "id:" + Id;
}
}
数据库操作
Spring-Data-Jpa（操作数据库非常简单，甚至不用写sql语句）
JPA(Java Persistence API)定义了一系列对象持久化的标准，目前实现这一规范的产品有Hibernate、TopLink等。
application.yml配置：
spring;
profiles:
active: dev
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/dbgirl
username: root
password: 123456
jpa:
hibernate:
ddl-auto: create // create如存在相同的表，会先删掉再重新创建爱
show-sql: true
- AOP统一处理请求日志 Spring两大核心原理（AOP、IOC）
AOP是一种编程范式，与语言无关，是一种程序设计思想
面向切面（AOP）Aspect Oriented Programming
面向对象（OOP）Object Oriented Programming
面向过程（POP）Procedure Oriented Programming
浅谈面向过程和面向对象
比如描述下雨了，我打开雨伞
面向过程（强调流程和规划）：假如下雨了，我打开了雨伞
面向对象：实例一个天气的对象，然后给这个对象赋予一个下雨的动作
实例一个我的对象，然后赋予一个打伞的动作（这些动作可以称之为方法）
其实就是换了个角度看世界，换个姿势处理问题。
AOP 是将通用逻辑从业务逻辑中分离出来
使用AOP第一步：再pom.xml中添加注解：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
第二步往常的做法是在启动类上添加一个注解，但是AOP就不用这样做。
第三步创建处理文件Javaclass-HttpAspect，要添加注解以引入到Spring容器中
@Aspect
@Component
public class HttpAspect {
//.. 表示只要是girlList这个方法里的任何参数，都会被拦截
// GirlController.*(..) 这样会拦截所有的
//@Before注解会在方法执行之前执行
@Before("execution(public * com.imooc.controller.GirlController.girlList(..))")
public void log() {
System.out.println(11111);
}
@After("execution(public * com.imooc.controller.GirlController.girlList(..))")
public void doAfter() {
System.out.println(22222);
}
上面代码等价于：
//spring下的日志框架
private final static Logger logger = LoggerFactory.getLogger(HttpAspect.class);
@Pointcut("execution(public * com.imooc.controller.GirlController.*(..))"")
public void log() {
}
@Before("log()")
public void doBefore() {
logger.info("11111");
}
@After("log()")
public void doAfter() {
logger.info("22222");
}
}
spring MVC 拦截器
什么是拦截器？
拦截器是指通过统一拦截从浏览器发往服务器的请求来完成功能的增强。
在web.xml中配置过滤器filter：
<filter>
<filter-name>encoding</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param> // 启动时的配置参数
<param-name>encoding</param-name>
<param-value>utf8</param-value>
</init-param>
</filter>
<filter-mapping>
<param-name>encoding</param-name>
<url-pattern>*</url-pattern> // 所有的请求都会经过过滤器
</filter-mapping>
springMVC可以通过配置过滤器来解决乱码问题，拦截器的工作原理和过滤器非常相似。
拦截器的实现：
1. 编写拦截器类实现HandlerInterceptor接口
public class TestInterceptor implements HandlerInterceptor{
..默认实现的拦截器方法..
}
2. 将拦截器注册到SpringMVC框架中
在springMVC默认的配置文件viewSpace-servlet.xml中注册
<mvc:interceptors>
<bean class="com.imooc.test.interceptor.TestInterceptor"></bean>
</mvc:interceptors>
3. 配置拦截器的拦截规则
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path:"/viewAll.form"/>// 配置拦截的路径（可通过*？正则来灵活配置路径）
<bean class="com.imooc.test.interceptor.TestInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
拦截器方法介绍：
public void afterCompletion (...){
//请求结束后调用的方法，用于资源的销毁
}
public void postHandle (...){
//可以通过其中ModleAndView参数来改变显示的视图，或修改发往视图的方法
arg3.setViewName("/hello2.jsp");
}
public boolean preHandle (HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
//返回值：表示我们是否需要将当前的请求拦截下来
//false：请求将被终止 true：请求会被继续运行
// Object arg2 表示的是被拦截的请求的目标对象
// 如不在web.xml中配置过滤器，可以在此处用拦截器解决乱码问题
arg0.setCharacterEncoding("utf-8");
// 对用户是否登录进行判断
if (arg0.getSession().getAttribute("user") == null) {
//如果用户没有登录，就终止请求，并发送到登录页面
arg0.getRequestDispatcher("/login.jsp").forward(arg0, arg1);
return false;
}
retutn true;
}
拦截器的使用场景：
使用原则：处理所有请求的共同问题
1. 解决乱码问题
2. 解决权限验证问题
附注：
拦截器和过滤器：
① 拦截器是基于java的反射机制的，而过滤器是基于函数回调。
② 拦截器不依赖与servlet容器，过滤器依赖于servlet容器。
③ 拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
④ 拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
⑤ 在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。
⑥ 拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。
Hibernate
什么是ORM？
ORM(Object/Relationship Mapping)：对象/关系映射
利用面向对象思想编写的数据库应用程序最终都是把对象信息报讯在关系型数据库中，于是需要编写很多和底层数据库
相关的SQL语句。这与面向对象思想格格不入！
写SQL语句有什么不好吗？
1. 不同的数据库使用的SQL语法不同。比如：PL/SQL与T/SQL
2. 同样的功能在不同的数据库中有不同的实现方式。比如分页SQL
3. 程序过分依赖SQL对程序的移植及扩展，维护等带来很大的麻烦。
需要一种可行的ORM框架技术：Hibernate
Hibernate是Java领域的一款开源的ORM框架技术，对JDBC进行了非常轻量级的对象封装。
闲话：其他主流的ORM框架技术：
1. MyBatis：前身就是著名的iBatis
2. Toplink：后被Oracle收购，并重新包装为Oracle AS TopLink
3. EJB：本身就是JAVAEE的规范，较笨重。
闲话2：JavaBeans实体类设计原则：
1. 公有的类
2. 提供公有的不带参数的默认的构造方法
3. 属性私有
4. 属性setter/getter封装
------------------------------------------------------------------------------------
hibernate.cfg.xml常用配置：
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<property name="hbm2ddl.auto">create|update|....</property>//慎用！！！
hibernate.show_sql：是否把Hibernate运行时的SQL语句输出到控制台，编码阶段便于测试
hibernate.format_sql：输出到控制台的SQL语句是否进行排版，便于阅读。建议设置为true
hbm2ddl.auto：可以帮助由java代码生成数据库脚本，进而生成具体的表结构。create|update|create-drop|validate
create：若表存在，则先删除表再重新创建
hibernate.default_schema：默认的数据库
hibernate.dialect：配置Hibernate数据库方言，Hibernate可针对特殊的数据库进行优化
注意：hibernate的前缀可省略，即hibernate.dialect等同于dialect。
create table studenrs (
SID integer not null,
SNAME varchar(255),
GENDER varchar(255),
BIRTHDAY datetime,
ADDRESS varchar(255),
primary key (SID)
)
insert into studenrs (
(SNAME, GENDER, BIRTHDAY, ADDRESS, SID)
values(?, ?, ?, ?, ?)
)
编写第一个Hibernate例子：
1. 创建hibernate的配置文件
2. 创建持久化类
3. 创建对象-关系映射文件
4. 通过hibernate API编写访问数据库的代码
附Hibernate的执行流程：
创建配置文件Configuration -> Hibernate.cfg.xml
创建SessionFactory -> User.hbm.xml(创建和销毁都相当耗费资源，通常一个系统内一个数据库只创建一个)
Session -> 执行save|delete|update|get
-> 开始事务Transation
-> tx.commit() session.close() 结束
transaction简介：
Hibernate对数据的操作都是封装在事务中，并且默认是非自动提交的方式。所以用session保存对象时，如果不开启事务，并且手工提交事务，对象并不会真正保存在数据库中
如果想让Hibernate想jdbc那样自动提交事务，必须调用session对象的doWork()方法，获得jdbc的connection后，设置其为自动提交事务模式。(注意：通常不推荐这样做)
1. 需要通过HttpServletResponse.setContentType方法设置Content-Type头字段的值，为浏览器无法使用某种方式或激活某个程序来处理的MIME类型，例如："application/octet-stream"或"application/x-msdownload"等
2.需要通过HttpServletResponse.setHeader方法设置Content-Disposition头的值为"attachment; filename=文件名"。
3.读取下载文件，调用HttpServletResponse.getOutputStream方法返回的ServletOutStream对象来向客户端写入附件文件内容。
文件上传后台实现步骤
1. 获取request当中的流信息，保存到临时文件
2. 从临时文件当中得到长传的文件名，及文件内容起止位置
3. 根据文件起止位置，读取上传文件内容，保存到本地
