SSM 学习笔记

系列文章目录

一、Spring Framework

1.1 IoC（Inversion of Control）

• 控制反转的含义：之前的代码new对象的控制权在程序员手中，现在将new对象的控制权交给外部，而这个外部就是由Spring提供的IoC容器，所有对象的创建都在IoC容器中进行。
  

1.2 DI（Dependency Injection）

1. service运行需要依赖dao对象，如果说IoC容器只是单独给一个service对象而不给dao对象，会出现空指针异常。所以此时IoC容器帮我们将有关系的Bean绑定好了创建。

2. 依赖注入的含义：在IoC容器中Bean与Bean之间建立依赖关系的整个过程
   

1.3 IoC代码案例

1. 添加案例中需要的类和接口

2. 在resource下添加Spring配置文件并配置bean相关信息

注意事项：bean定义时id属性在同一个上下文中(配置文件)不能重复

<?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标签表示配置bean-->
<!--    id属性是给bean起名字-->
<!--    class属性代表bean的定义类型-->

    <bean id="bookDao" class="com.rose.dao.BookDaoImpl"/>
    <bean id="bookService" class="com.rose.service.BookServiceImpl"/>
    
</beans>

3. 使用Spring提供的接口创建IoC容器才能拿到bean对象

ApplicationContect是一个接口不能实例化

public class App {
    public static void main(String[] args) {
        //获取 IoC容器
        ApplicationContext context= new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取 bean
        BookService bookService=(BookService) context.getBean("bookService");
        bookService.save();
    }
}

1.4 DI代码案例

1. Service中还存在new的形式创建对象，此时需要完全将创建对象的能力交给Spring，先删除Service中new的方式

2. 提供一个setter方法将Dao对象传入Service

在BookServiceImpl类中,为BookDao提供setter方法

public class BookServiceImpl implements BookService{
    //删除业务层使用new方式创建dao对象
    private BookDao bookDao;

    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }
    //提供对应set方法注入dao对象
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

3. 在配置文件中，配置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标签表示配置bean-->
<!--    id属性是给bean起名字-->
<!--    class代表bean的定义类型-->

    <bean id="bookDao" class="com.rose.dao.BookDaoImpl"/>

    <bean id="bookService" class="com.rose.service.BookServiceImpl">
<!--            配置service和dao的关系-->
<!--        name属性表示配置那一个具体属性-->
<!--        ref表示参考哪一个bean-->
    <property name="bookDao" ref="bookDao"/>
    </bean>

</beans>

虽然id和ref都是bookDao，name指的是属性名称，ref是需要依赖注入的bean

1.5 Bean的实例化方法

默认情况下，Spring创建的bean对象都是单例的

1. 构造方法

public class BookDaoImpl implements BookDao{
    public BookDaoImpl(){
        System.out.println("book dao constructor is running...");
    }
    @Override
    public void save() {
        System.out.println("book dao save... ");
    }
}

2. 静态工厂

public interface OrderDao {
    void save();
}

public class OrderDaoImpl implements OrderDao{
    @Override
    public void save() {
        System.out.println("order dao save ...");
    }
}

//配置信息
<!--    使用工厂方法实例化Bean-->
    <bean id="orderDao" class="com.rose.factory.OrderDaoFactory" factory-method="getOrderDao">
    </bean>

3. 实例工厂

public interface UserDao {
    public void save();
}

public class UserDaoImpl implements UserDao {
    public void save() {
      System.out.println("user dao save ...");
      }
}

public class UserDaoFactory {
    public UserDao getUserDao(){
         return new UserDaoImpl();
    }
}

在spring的配置文件中添加以下内容

<bean id="userFactory" class="com.rose.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

4. FactoryBean的拓展方法（重点）
   
   
   
   

1.6 setter注入

• 注入引用类型
  
• 注入基本类型

public class BookDaoImpl implements BookDao{
    private int connectionNum;
    private String baseName;

    public void setBaseName(String baseName) {
        this.baseName = baseName;
    }

    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }

    @Override
    public void save() {
        System.out.println("book dao save... "+connectionNum+baseNum);
    }
}

//配置信息
 <bean id="bookDao" class="com.rose.dao.BookDaoImpl">
        <property name="connectionNum" value="10"/>
        <property name="baseName" value="mysql"/>
    </bean>

1.7 构造器注入

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    private UserDao userDao;

    public BookServiceImpl(BookDao bookDao, UserDao userDao) {
        this.bookDao = bookDao;
        this.userDao = userDao;
    }

    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
        userDao.save();
    }
    
//配置信息
    <bean id="bookDao" class="com.rose.dao.BookDaoImpl"/>
    <bean id="userDao" class="com.rose.dao.UserDaoImpl"/>

    <bean id="bookService" class="com.rose.service.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>

• 两种简化配置参数的方法
  

1.8 小结

二、注解开发

2.1 注解定义Bean

1. 添加配置文件信息

<?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:content="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">
    <content:component-scan base-package="需要扫描的包的路径"/>
</beans>

2. 为实现的类添加注解

@Component注解不可以添加在接口上，因为接口是无法创建对象的。

• 配置文件与注解对应关系

• Component注解的衍生注解
  

2.2 纯注解开发（Spring 3.0）

1. 创建一个配置类，并标识该类为配置类，注解替换application.xml

@Configuration //配置类
@ComponentScan("com.rose.dao")//包扫描配置信息
public class SpringConfig {
}

2. 读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象

2.3 bean的生命周期管理

• @Scope注解 配置bean为单例或者为非单例模式，默认为单例
  
  
• bean的生命周期管理，在初始化方法上添加@PostConstruct和在销毁方法上@PreDestroy注解
  
• 要想看到两个方法执行，需要注意的是destroy（）方法只有在容器关闭的时候才会执行，所以需要修改App的类为Annotation类
  

2.4 依赖注入（重点）

Spring为了使用注解简化开发，并没有提供构造函数注入、setter注入对应的注解，只提供了自动装配的注解实现

• @Autowired 自动装配（注定引用类型注入）

@Autowired可以写在属性上，也可也写在setter方法上，最简单的处理方式是写在属性上并将setter方法省略

• 自动装配原理

自动装配基于反射设计创建对象并通过暴力反射为私有属性进行设值，普通反射只能获取public修饰的内容，暴力反射除了获取public修饰的内容还可以获取private修改的内容，所以此处无需提供setter方法

• @Autowired是按照类型装配，如果一个接口有多个实现类（相同类型的bean）就需要配合@Qualifier注解实现按照名称注入
  
  
• 使用@Value简单类型注入
  
• 注解读取properties配置文件文件信息
  
  

2.5 注解开发管理第三方bean（重点）

• 使用独立的配置类管理第三方Bean

@Bean注解的作用是将方法的返回值制作为Spring管理的一个bean对象，第三方配置类不用加@Configuration注解

@Configuration //核心配置类
@Import(JdbcConfig.class)//导入外部配置类
@ComponentScan({"com.rose.dao","com.rose.service"})
public class SpringConfig {

}

public class JdbcConfig {
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://127.0.0.1:3306/spring_db")
    private String url;
    @Value("root")
    private String username;
    @Value("root")
    private String password;

    @Bean
    //该方法的返回值就是要创建的Bean对象类型
    public DataSource dataSource(){
        DruidDataSource dataSource=new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

2.6 为第三方Bean注入资源

• 简单类型注入
  
  
  

• 引用类型注入

2.7 总结

三、AOP

3.1 概念（无侵入式编程思想）

AOP(Aspect Oriented Programming)面向切面编程：在不惊动原始设计的基础上（不用修改源代码）为其进行功能增强。Spring的AOP是对一个类的方法在不进行任何修改源代码的前提下实现增强

• 代码解析

@Repository
public class BookDaoImpl implements BookDao {
    public void save() {
//记录程序当前执行执行（开始时间）
        Long startTime = System.currentTimeMillis();
        //业务执行万次
         for (int i = 0;i<10000;i++) {
             System.out.println("book dao save ...");
            }
         //记录程序当前执行时间（结束时间）
         Long endTime = System.currentTimeMillis();
        //计算时间差
         Long totalTime = endTime-startTime;
         //输出信息
         System.out.println("执行万次消耗时间：" + totalTime + "ms");
         }
 public void update(){
         System.out.println("book dao update ...");
         }
 public void delete(){
         System.out.println("book dao delete ...");
         }
 public void select(){
         System.out.println("book dao select ...");
         }
 }

只有save方法中存在打印万次和记录时间的代码，但是在App容器中获取BookDao对象之后调用四个方法，会发现update和delete方法中也执行了打印万次和记录时间的功能。这个案例中其实就使用了Spring的AOP，在不惊动(改动)原有设计(代码)的前提下，想给谁添加功能就给谁添加

• 实现原理：将其它方法想要增强的功能单独写成一个方法。

• 连接点

对于上面的案例中BookServiceImpl中有save，update，delete和select方法，这些方法就叫连接点

• 切入点

在BookServiceImpl的四个方法中，update和delete只有打印没有计算万次执行消耗时间，但是在运行的时候已经有该功能，那也就是说update和delete方法都已经被增强，所以对于需要增强的方法就叫切入点

• 通知

执行BookServiceImpl的update和delete方法的时候都被添加了一个计算万次执行消耗时间的功能，将这个功能抽取到一个方法中，换句话说就是存放共性功能的方法叫通知

• 切面

通知是要增强的内容，会有多个，切入点是需要被增强的方法，也会有多个，哪个切入点需要添加哪个通知，就需要提前将它们之间的关系描述清楚，那么对于通知和切入点之间的关系描述就叫切面

• 通知类

通知是一个方法，方法不能独立存在需要被写在一个类中，这个类我们也就叫通知类

3.2 AOP工作流程代码示例

1. 导入aspect坐标，添加依赖
   

        
		<dependencies>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.9.4</version>
		</dependency>
       <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.2.10.RELEASE</version>
       </dependency>
 </dependencies>

2. 制作连接点方法（原始方法，Dao接口和实现类）

@Repository
public class BookDaoImpl implements BookDao{

    @Override
    public void save() {
        //打印当前系统时间
        System.out.println(System.currentTimeMillis());
        System.out.println(" book dao save ...");
    }

    @Override
    public void update() {
        System.out.println(" book dao update ...");
    }
}

3. 定义通知类和定义通知（需要增强的功能）
   
4. 定义切入点（实际上是找到需要增强功能的方法的位置）

切入点定义依托一个不具有实际意义的方法进行，无参数，无返回值

6. 制作切面，绑定切入点与通知的关系


7. 将通知类配给容器，并标识为切面类

8. Spring开启AOP功能

3.3 AOP工作流程解析

AOP是基于Spring容器管理的bean做的增强，核心本质：代理模式

1. Spring容器启动，加载需要被加载的Bean
   

2. 读取所有切面配置中的切入点，并不是所有定义的切入点都会被使用

3. 初始化Bean，需要被实例化的bean中类的方法和定义的切入点进行匹配

4. 验证容器中产生的对象是否为代理对象Proxy

不能直接打印对象，从上面两次结果中可以看出，直接打印对象走的是对象的toString方法，不管是不是代理对象打印的结果都是一样的，原因是内部对toString方法进行了重写。

3.4 切入点表达式

切入点：要进行增强的方法
切入点表达式：要进行增强的方法的描述方式

• 语法格式

描述方法无论是用接口的方法还是实现类的方法都可以，推荐使用接口

• 一般需要增强功能的方法都是访问修饰符都是public，可以省略
  
• 通配符

" * "和 " … "两个符号放在方法参数有区别，前者表示有单个任意独立的参数，后者表示多个或者一个任意参数

3.5 AOP通知类型

• 示例代码

@Repository
public class BookDaoImpl implements BookDao{

    @Override
    public int select() {
        System.out.println(" book dao select is running ...");
        return 100;
    }
    @Override
    public void update() {
        System.out.println(" book dao update is running ...");
    }
}

• 前置通知

@Component//加载到Spring容器
@Aspect//当作AOP处理而不是Bean
public class MyAdvice {
    //定义切入点
    @Pointcut("execution(void com.rose.dao.BookDao.update())")
    private void pt(){}

    //通知
    //绑定切入点和通知类的方法
    @Before("pt()")//将增强的方法写到原始方法的最前面
    public void before(){
        System.out.println(" before advice ...");
    }
}

• 后置通知

@After("pt()")
    public void after(){
        System.out.println(" after advice ...");
    }

• 环绕通知（重点）

环绕通知需要调用原始方法，并且调用原始方法时需要抛出异常

@Around("pt()")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println(" before around advice ..." );
        pjp.proceed();
        System.out.println(" after around advice ..." );
    }

使用环绕通知的话，要根据原始方法的返回值来设置环绕通知的返回值。返回的是Object而不是int的主要原因是Object类型更通用

//定义新的切入点
    @Pointcut("execution(int com.rose.dao.BookDao.select())")
    private void pt2(){}

    @Around("pt2()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println(" before around advice ..." );
        Object ret=pjp.proceed();
        System.out.println(" after around advice ..." );
        //可以篡改原始方法返回值
        //return 200
        return ret;
    }

3.6 测量业务层接口万次执行效率案例（重点掌握）

1. 在Spring配置类中添加注解，开启SpringAOP功能呢
   
2. 创建AOP通知类，切入点匹配业务层所有方法，方法中参数任意
   
3. 定义环绕通知，完成核心业务

@Component
@Aspect
public class ProjectAdvice {
    //定义切入点
    //匹配业务层所有方法
    @Pointcut("execution(* com.rose.service.*Service.*(..))")
    private void pt(){}

    //需要增强的功能
    @Around("ProjectAdvice.pt()")//使用的是环绕通知,在原始方法前后增加功能
    public void serviceSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //记录开始时间
        long start=System.currentTimeMillis();
        for (int i = 0; i <10000 ; i++) {
            //调用原始方法
            pjp.proceed();
        }
        //记录结束时间
        long end=System.currentTimeMillis();
        System.out.println("业务层接口万次执行时间: "+(end-start)+"ms");
    }
}

4. 完善核心业务，区分测试类中业务层接口具体执行的方法的效率
   
   

@Component
@Aspect
public class ProjectAdvice {
    //定义切入点
    //匹配业务层所有方法
    @Pointcut("execution(* com.rose.service.*Service.*(..))")
    private void pt(){}

    //需要增强的功能
    @Around("ProjectAdvice.pt()")//使用的是环绕通知,在原始方法前后增加功能
    public void serviceSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行签名信息
        //封装了一次执行过程
        Signature signature = pjp.getSignature();
        //通过签名获取执行操作名称(接口名)
        String className = signature.getDeclaringTypeName();
        //通过签名获取执行操作名称(方法名)
        String methodName = signature.getName();
        //记录开始时间
        long start=System.currentTimeMillis();
        for (int i = 0; i <10000 ; i++) {
            //调用原始方法
            pjp.proceed();
        }
        //记录结束时间
        long end=System.currentTimeMillis();
        System.out.println("万次执行时间: "+className+"."+methodName+"---->"+(end-start)+"ms");
    }
}

3.7 AOP通知获取数据

• 获取参数

非环绕通知获取方式是在方法上添加JoinPoint，通过JoinPoint来获取参数
获取参数的结果使用的对象数组，因为方法中参数可能不唯一

使用JoinPoint的方式获取参数适用于前置、后置、返回后、抛出异常后通知。

环绕通知使用的是ProceedingJoinPoint，因为ProceedingJoinPoint是JoinPoint类的子类，所以对于JoinPoint类中所有的方法会被继承，例如getArgs()方法，pjp可直接使用

• 获取返回值

只有返回后AfterReturing和环绕Around这两个通知类型可以获取

• 获取异常

3.8 百度网盘密码兼容处理案例

• 代码示例

public interface ResourceService {
    public boolean openURL(String url,String password);
}

@Service
public class ResourceServiceImpl implements ResourceService{
    @Autowired
    private ResourceDao resourceDao;

    @Override
    public boolean openURL(String url, String password) {
        //将数据转调给业务层执行
        return resourceDao.readResources(url,password);
    }
}

public interface ResourceDao {
    boolean readResources(String url,String password);
}

@Repository
public class ResourceDaoImpl implements ResourceDao{
    @Override
    public boolean readResources(String url, String password) {
        //补充一个模拟检验密码的功能
        return password.equals("root");
    }
}

• 创建配置类，开启Spring AOP注解功能，编写App运行类

@Configuration //配置类
@ComponentScan("com.rose")
@EnableAspectJAutoProxy//告诉Spring有使用注解开发的AOP,启动配置中的@Aspect注解
public class SpringConfig {
}

public class AppForAnnotation {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);
        ResourceService resourceService=context.getBean(ResourceService.class);
        boolean flag=resourceService.openURL("http://pan.baidu.com/xixi","root ");
        System.out.println(flag);
    }

• 需求是使用AOP将参数进行统一处理，不管输入的密码 root 前后包含多少个空格，最终控制台打印的都是true。完成核心业务，处理参数中的空格

@Component
@Aspect
public class ProjectAdvice {
    //定义切入点
    //匹配业务层所有方法,将带空格的参数都去空格操作
    @Pointcut("execution(boolean com.rose.dao.*Dao.*(..))")
    private void pt() {}

    @Around("pt()")
    public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
        //获取原始方法中的参数
        Object[] args = pjp.getArgs();
        //去除原始方法传入的字符串参数带有空格的字符串参数
        //foreach只能读数据,不可以修改原始数据
        for (int i = 0; i <args.length ; i++) {
            //判断是不是字符串
            if(args[i].getClass().equals(String.class)){
                //取出数据后转换类型,在更新数据
                args[i] = args[i].toString().trim();
            }
        }
        //将修改后去除空格的参数传入原始方法中
        Object ret=pjp.proceed(args);
        return ret;
    }
}

3.9 总结

• 核心概念：AOP的作用就是在不惊动原始设计的基础上对原始方法进行功能增强

• 切入点表达式

• 五种通知类型

• 通知中获取参数

四、Spring事务

4.1 Spring事务简介

• 从名称上可以看出，我们只需要给它一个DataSource对象，它就可以帮你去在业务层管理事务。其内部采用的是JDBC的事务。所以说如果你持久层采用的是JDBC相关的技术，就可以采用这个事务管理器来管理你的事务。而Mybatis内部采用的就是JDBC的事务，所以后期我们Spring整合Mybatis就采用的这个DataSourceTransactionManager事务管理器。
  

• 完成Spring事务管理操作步骤
  

• 建议注解添加在接口上或者接口方法上
  

• 在JDBC的配置类中设定事务管理器

• 使用JDBC的事务管理器DataSourceTransactionManager
  
• 配置类中开启事务
  
  
• 总结
  
  
  

4.2 事务角色

事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法

事务协调员：加入事务方，在Spring中通常指代数据层方法CURD，也可以是业务层方法

4.3 事务属性

readOnly：true只读事务，false读写事务，增删改要设为false，查询设为true。

timeout：设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚，-1表示不设置超时时间。

rollbackFor：当出现指定异常进行事务回滚

noRollbackFor：当出现指定异常不进行事务回滚

• rollbackFor：Spring的事务只会对Error异常和RuntimeException异常及其子类进行事务回滚，其他的异常类型是不会回滚的，比如IOException

4.4 案例：转账记录追加日志（事务传播行为）

当不出现异常时，转账成功并且日志成功打印；当出现异常时就不会转账也不会打印日志，这是因为日志的记录与转账操作隶属同一个事务，同成功同失败

• 事务传播行为：事务协调员对事务管理员所携带事务的处理态度
  
  
• 将事务加入新的事务
  
  supports（支持事务）：原来存在事务，就加入事务；原来没有就不加入

mandatory：原来操作带事务就可以加入事务，如果不携带事务就调用方法会报错

never：开事务调用就会报错

五、SpringMVC

SpringMVC是隶属于Spring框架的一部分，主要是用来进行Web开发，是对Servlet进行了封装。

5.1 SpringMVC简介

• web程序基于三大框架实现
  
  
• 入门案例
  
  
  
  
• 工作流程分析，启动服务器初始化过程
  
  
  
• 单次请求过程
  
• bean加载控制
  
  

5.2 请求映射路径

• 当UserController和BookController中存在相同请求映射路径时，Tomcat启动后会产生报错
  
  
  
• 使用注解在类上设定请求路径前缀
  
  

5.3 请求参数

• Get请求携带多个参数参数
  
  

• 解决中文中文乱码的情况
  

• Post请求携带多个参数，需要将请求参数放在请求体body中
  
  
  

• pojo实体类传参
  
  

• pojo实体类中嵌套实体类
  
  

• 数组传参，例如注册网站需要提交个人爱好，爱好肯定有很多，需要以数组形式提交
  

• 集合参数
  
  

• 总结：如果请求参数名称与形参变量名称不对应，使用 @Param注解
  

5.4 json数据传输参数

• 准备工作
  
  
• JSON普通数组
  
• 现在请求的数据不在请求参数 param 中，所以不能使用@RequestParam注解；而是在请求体body中，使用注解@RequestBody 将前端传入的 JSON 数据映射到形参的集合对象中作为数据保存
  
  
• JSON对象
  
  
• pojo实体类内部嵌套一个实体类
  
• JSON对象数组
  
  
  
• @RequestParam 主要应用于url地址传参，表单传参
• @RequestBody 主要用于json格式的数据传参
  

5.4 日期型参数传参

• 统一使用：yyyy/MM/dd HH:mm:ss 格式
  
  
• SpringMVC内部实现类型转换的原理

• convert接口无法实现类型转换的功能，靠的是该接口下众多的实现类，例如 HttpMessageConverter 实现类就是 json 与 对象 类型转换的实现类
  

5.5 响应

• SpringMVC接收到请求和数据后，进行一些处理，当然这个处理可以是转发给Service，Service层再调用Dao层完成的，不管怎样，处理完以后，都需要将结果告知给用户。

• 响应页面（了解）
  

• 注意不要添加 @RequestBody注解，否则会将返回值当作 json 数据处理
  

• 响应文本数据（了解）
  
  

• 响应json对象 ，将pojo实体类 转换为 json格式的数据
  
  

• 响应Json对象集合
  
  

• @ResponseBody注解激活类型的自动转换，设置当前控制器返回值作为响应体
  
  
  内部转换原理是一个专门用于 http 消息转换的接口：HttpMessageConvert接口
  

六、REST风格

6.1 REST简介

• REST（Representational State Transfer），表现形式状态转换，它是一种软件架构风格而不是一种规范。简单理解：REST风格是一种访问网络资源的风格
  
• 常用的行为动作

• REST只是一种风格而不是规范，不一定非要按照这个风格访问资源
  

6.2 RESTful入门案例

• 新增 POST，并修改请求路径为 /users
  
• 删除 DELETE
  
• 传递参数：该参数来自于请求路径，与之前 “？id=1” 的传参方式不同，传递参数时修改路径为 /users/{id}
  
• 多个路径参数传递书写格式
  
• 修改 PUT
  
  
  
  
• 三种传参注解
  

6.3 RESTful快速开发

• 等同于等同于@Controller + @ResponseBody
  
  

6.4 基于Restful风格页面数据交互

• 准备工作
  
  
  

七、SpringBoot

SpringBoot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化 Spring 应用的初始搭建以及开发过程

7.1 创建 SpringBoot 步骤

• idea中创建SpringBoot
  
  
  
  
  

• SpringBoot官网构建项目
  
  
  
  

• 启动服务器
  

• spring 程序 和 springboot 程序对比
  
  
  

• 起步依赖starter带来的好处，可以省略写依赖时考虑版本问题
  
  
  

• 辅助功能切换 web 服务器
  
  
  

7.2 SpringBoot 工程快速启动

• Jar支持命令行启动必须依赖maven插件支持
  
• 在idea中打Jar包的步骤，在Maven里点击package命令
  
  
  

7.3 配置文件

• application.properties
  
  

• application.yaml和application.yml
  
  

• 配置文件自动提示功能设置方法
  
  
  

• 三种配置文件优先级
  

• info级别的日志是默认级别
  

7.4 yaml配置文件（主流配置文件）

• 语法要求
  

7.5 读取配置文件三种格式

• @Value（直接读取）
  
  
• 自动注入Environment对象（封装后读取）
  
• 自定义实体类封装属性（封装后读取）
  
• 使用自定义封装类实例化对象的get方法就可以获取配置文件中对应的属性
  
  

7.6 多环境启动配置（yml配置）

• 防止配置文件中中文乱码导致打jar包失败的解决方案，在Setting中找到File Encoding修改字符编码
  
• yml多环境启动可以配置在一个配置文件中
  
  
  
• 多环境命令行参数启动

可以使用临时参数覆盖原配置文件中参数

Spring官网配置优先级说明

• 多环境开发与兼容（Maven与Boot）
  
  
  
• Maven传递信息给配置文件需要解析 ${} 中内容，加上对资源文件（配置文件）占位符解析的插件即可
  
  
• 配置文件分类，idea原始配置文件处于最低级 1 级
  
  
  
  
  
  

7.7 整合第三方技术

• Spring整合Junit示例
  
• SpringBoot整合Junit
  
  
• SpringBoot整合Mybatis
  
• 勾选 Mybatis 起步依赖和 需要的数据库驱动（图例中加的是mysql的驱动）
  
• 设置数据源参数
  
• 定义数据层接口与映射配置
  
• 测试类中测试功能
  

八、MybatisPlus

8.1入门案例

• 由于 MP 起步依赖并未被收录到 idea 的系统内置配置，无法直接选择加入，需要手动在 pom.xml 中配置添加
  
• 补全pom.xml依赖
  
• 从MP的依赖关系可以看出，通过依赖传递已经将 MyBatis 与Spring整合 Mybatis 的jar包导入，所以我们在创建工程时不需要额外添加 MyBatis 的相关 jar 包
  
• 配置文件和创建实体类
  
• 核心步骤：定义数据层接口，之前 Mybatis 需要在接口中写具体的实现方法和 sql 语句，现在全部省略，只需要在持久层（Dao层）接口继承 BaseMapper 接口即可，在泛型中传入相关的pojo实体类
  
• 测试用例
  

8.2 标准CRUD使用

• 新增
  
  
• 删除
  
• 修改

虽然是按照ID查询，但是最后参数需要传入修改的对象

• 查询
  
  
• lombok

8.3 分页功能制作

• 分页查询的返回值是 Page 类型
  

• 分页对象常用方法
  

• 核心步骤：设置分页拦截器，MybatisPlus中提供了一个拦截器，在这个 拦截器 中添加 分页拦截器 ，只有添加分页拦截器才能显示分页功能。配置类和方法上需要添加注解
  
  

• 配置mybatisplus执行sql语句的运行日志
  
  

8.4 条件查询三种格式

• 构建条件查询，主要通过 Wrapper 接口实现类添加条件
  
• 第一种构建条件查询对象：QueryWrapper
• lt 小于 less than
• gt 大于 greater than
  
• 第二种构建条件查询对象：基于Lambda格式的QueryWrapper
  
  第三种构建条件查询对象：LambdaQueryWrapper（推荐使用）
  
• 多条件查询，查询10到30岁之间的人，and 关系
  
  
• 多条件查询，小于10岁或者大于30的人，or 关系
  

8.5 条件查询 null 判定

• 实体类User类中，如何使用 age 属性接收页面提交的两个数据
  
• 新建一个模型类，让其继承User类，并在其中添加age2属性，UserQuery在拥有User属性后同时添加了age2属性
  
• 主要理解校验参数的格式
  

8.6 查询条件设置

• lambda表达式中两个冒号 “::” 表示方法的引用
• eq（）等值查询，相当于 =
  
• selectList()是查询全部，selectOne是查询单个
  
• 范围查询
  
• between（）方法代码案例
  
• 模糊匹配，查询 name 字段中，以 “J” 结尾的name属性值
  
  

8.7 映射匹配兼容性

• 表字段与编码属性设计不同步
  
• 可以使用@TableFile注解解决表字段名与实体类属性名称不一致的问题
  
• 编码中添加了数据库中为定义的字段。将注解中 exist 属性设置为 false （表示该字段在数据库中不存在），在数据库进行select查询时就不会使用这个查询字段
  
• 采用默认查询时开放了所有字段查询权限，比如在查询用户信息时我们业务中要求不能显示用户密码 password 属性值。在注解中设置 select 属性为 false，此属性与映射配置不冲突
  
• 表名与实体类名称设计不同步，注解@TableName来设置表与模型类之间的对应关系
  

8.8 id自增策略

• AUTO策略，使用数据库自带的 id 自增策略
  
  
  
• INPUT策略，手工添加主键 id 值，同时需要将数表中的自增策略关闭
  
  
  
  
• ASSIGN_ID策略 雪花算法生成 id 值（自动生成），同时添加数据时不设置 id，生成的 id 是一个 long 类型，可兼容数值型和字符串类型
  
• 雪花算法（了解）
  
• ASSIGN_UUID策略，主键类型不能是 Long ，只能是 String 类型
  
• 简化配置，将 id 自增策略写在配置文件中
  
  
• 全局配置数据表前缀
  
  

九、Mybatis

9.1 简介

9.2 快速入门

1. 导入相应的坐标

 <dependencies>
<!--        mybatis依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.5</version>
        </dependency>

        <dependency>
<!--            mysql 驱动,连接数据库-->
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>

        <dependency>
<!--            单元测试-->
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        
 <!-- 添加slf4j日志api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.20</version>
        </dependency>
        
        <!-- 添加logback-classic依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        
        <!-- 添加logback-core依赖 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
        </dependency>	

2. 在模块下的resources目录下创建mybatis的核心配置文件 mybatis-config.xml ，内容如下：

mybatis官网链接

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
    <!--        数据库连接信息-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
<!--加载 sql 映射文件,指定映射文件路径-->
<!--        <mapper resource="org/example/mapper/UserMapper.xml"/>-->

<!--        Mapper 代理方式-->
        <package name="org.example.mapper"/>

    </mappers>
</configuration>

3. 编写 SQL 映射文件：统一管理sql语句，解决硬编码问题。在模块的 resources 目录下创建映射配置文件 UserMapper.xml，内容如下

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
namespace:名称空间
id：sql语句的唯一标识，不可以重复
resultType：数据返回结果的类型,本案例中我们需要返回一个User类型,并写出相应的路径
-->

<mapper namespace="test">
    <select id="selectAll" resultType="org.example.User">
        select * from tb_user;
    </select>
</mapper>

4. 创建POJO实体类，实体类属性与数据库字段相对应

5. 编辑一个测试类 Main

public class Main {
    //1.加载mybatis核心配置文件, 获取 SQLSessionFactory
    public static void main(String[] args) throws IOException {
        //获取核心配置文件的路径
        String resource = "mybatis-config.xml";

        //文件IO 资源加载的类Resource 将文件中的字符串传入,返回一个字节输入流
        InputStream inputStream = Resources.getResourceAsStream(resource);

        //SqlSessionFactoryBuilder通过builder方法把流传入就能返回工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //2.获取SqlSession对象,用来执行sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //3.执行sql 参数传入mapper文件中相应的sql语句唯一标识id
        List<User> users = sqlSession.selectList("test.selectAll");
        System.out.println(users);

        //4.释放资源
        sqlSession.close();
    }
}

6. 解决SQL映射文件的警告提示
   
   
   
   
   

9.3 Mapper 代理开发（主流开发，重点掌握）

• 通过获取Mapper接口代理对象，接口中包含很多的方法，这些方法与配置文件中 id 名称一一对应。只要获取这个Mapper代理对象之后就可以调用里面的方法。
  
• Mapper代理步骤
  

1. 定义与SQL映射文件同名的Mapper接口，并且将Mapper接口和SQL映射文件放置在同一目录下，路径要相同。如下图
   
2. 设置SQL映射文件的namespace属性为Mapper接口全限定名
   
3. 在 Mapper 接口中定义方法，接口中的方法名就是SQL映射文件中sql语句的id，并保持参数类型和返回值类型一致
   
4. 编辑代码，首先获取sqlSession，通过session获取对应接口Mapper接口的代理对象，同时找到该目录下同名的Mapper的对应xml配置文件，通过userMapper.selectAll调用方法，获取到sql语句

public class Main {
    //1.加载mybatis核心配置文件, 获取 SQLSessionFactory
    public static void main(String[] args) throws IOException {
        //获取核心配置文件的路径
        String resource = "mybatis-config.xml";

        //文件IO 资源加载的类Resource 将文件中的字符串传入,返回一个字节输入流
        InputStream inputStream = Resources.getResourceAsStream(resource);

        //SqlSessionFactoryBuilder通过builder方法把流传入就能返回工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        //2.获取SqlSession对象,用来执行sql语句
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //3.执行sql 获取UserMapper的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = userMapper.selectAll();
        System.out.println(users);

        //4.释放资源
        sqlSession.close();
    }
}

• 解决多映射文件：Mapper代理可以采取包扫描方式，扫描所有映射文件
  

9.4 Mybatis核心配置文件

所有配置遵循前后顺序

• environment配置环境，通过default属性切换不同的环境
  
• 类型起别名
  
  

9.5 配置文件完成增删改查（重点）

• 准备工作，省略创建数据表过程
  
  
  

• 查询所有数据功能

映射文件在resource文件下的路径与同名接口的路径相同

• 解决 实体类属性名称 和 数据表字段名称 不一样导致数据无法自动封装的问题（重点掌握）

• 第一种方法：起别名（不推荐），让别名和实体类名称相同
  

• 第二种方法：使用resultMap定义字段和属性的映射关系（常用），标签内的id是设置主键的映射关系，result设置一般字段的映射

• 查询——查看详情
  
  
  
  
  
  
• 参数占位符（面试重点）

从下面两个例子可以看出，以后开发我们使用 #{} 参数占位符。

• sql语句中特殊字段的两种处理

9.6 多条件查询

• 思考对应的多条件查询语句表达式
  

status=？：只有两种状态，启用=1，禁用=0

companyName和brandName不用 ？ 而用 like 是因为用户并不知道企业名称全称和品牌名字全称，所以使用模糊匹配来包含用户查询输入的信息

• Mybatis提供三种多种参数接收方式（重点掌握）

• 散装参数：使用 @Param注解 让多个参数明确对应的占位符，例如 int status 参数对应的是注解括号内 " status " 占位符。格式 @Param（“SQL参数占位符名称”）

• 封装对象：将所有参数封装为对象，占位符需要对应参数时，从对象的get方法中获取，这意味着占位符的名称要和对象属性名称相同，不一样就找不到对应的get方法

• 封装为Map集合：key值保存占位符，value值保存对应的参数

• 执行相应的测试方法，参数顺序需要与映射文件中参数占位符顺序相同
  
  

9.7 多条件动态SQL（多条件查询优化）

• 多条件查询时，用户不一定每一次查询都会输入三个条件。所以SQL语句随着用户的输入或者外部条件的变化而变化，我们称之为动态SQL
  
• if标签：条件判断，判断参数是否有值
• test属性：逻辑表达，进行条件判断
  
  
  
• 第一个条件where之后不需要添加逻辑运算符 and或者or，所以当用户没有输入status条件后，sql语句会报错
  
• where标签，此时需要给所有条件都加上and，包括第一个条件
  
  

9.8 单条件动态查询 choose（when）

• 从多条件中选择一个条件查询，用户将对应选择的条件传入后台
• 
  
• choose标签
  
  
  

9.9 添加&修改

如果需要手动提交事务：

• 获取主键返回
  
  sql语句虽然将数据库中的id字段自动添加了数据，但是没有绑定到实体类中对应的id属性
  
• 修改动态字段，使用动态修改字段的方法包括了修改全部字段

set标签的作用：

1.可以处理逗号的问题（例如用户不想修改status的数据，此时description字段就是最后一个数据并且带逗号，执行方法时有sql语法错误）

2.可以处理什么字段都不修改的情况（用户所有字段都不修改时，sql语句会包含一个set，会造成sql语法错误）

9.10 删除功能

• 批量删除

• 对应的sql映射文件中，sql语句是动态变化的，因为每次要删除多少个文件是不确定的。需要用foreach标签遍历参数中的数组

• collection属性：默认写的是 “array” ，但是可以用@Param注解在参数中修改原 key 值名称
• item属性：写对应的占位符，替换为 ？后，还需要逗号连接
• separator属性：分隔符自动添加，并且迭代至最后一个数据时，不添加分隔符
  
  

9.11 参数传递

• 单个参数
  
• Mybatis提供了 ParamNameResovler 类对参数进行封装
  
  
• 多个参数
  
• 有多个参数时，Mybatis会把这些参数封装为 Map 集合，默认 key 值名称是 arg 和 param
  
  
  
• 在接口方法参数上使用 @Param 注解，Mybatis 会将 arg 开头的键名替换为对应注解的属性值。
  
  
• 结论
  

十、SSM整合

10.1 表现层与前端数据传输协议定义

• 由于表现层不同功能的开发，返回的数据类型会随着业务数量的增多而增多。对于前端开发人员在解析数据的时候就比较凌乱了，所以对于前端来说，如果后台能够返回一个统一的数据结果，前端在解析的时候就可以按照一种方式进行解析
  
• 统一前端接收数据类型格式
  
  
• 设置返回数据结果类型
  
  
• 设置统一数据返回的结果编码
  
• 修改BookController，将所有方法返回值设定为 Result类
  

10.2 统一异常处理

• 出现异常的情况

• 常见的异常种类
  
• 异常处理器 AOP思想
  
• @RestControllerAdvice 可以声明一个处理异常的类
• @ExcepetionHandler 定义当前是处理哪一种异常类型的
  
• 常见异常种类和异常处理方案

• 异常解决具体方案
  

1. 先通过自定义异常，完成BusinessException和SystemException的定义
   

2. 自定义异常编码
   

3. 将可能出现的异常包装成自定义异常
   
   

4. 异常处理器拦截并处理异常
   

5. 异常处理器效果对比
   

十一、JavaWeb 前端知识

11.1 HTML

HTML介绍

快速入门

基础标签

• hr 标签
  

• font 标签，已过时，后期通过css改变字体样式

• br 换行标签

• p 段落标签，比换行标签 br 展示段落效果更好

• b 、i、u标签：加粗 、斜体、下划线标签，后期也可以通过 css 改变字体样式

• center 居中标签，过时标签，后期通过 css 改变文字样式
  
• 页面中的特殊字符
  
  

图片、视频、音频标签

• 这些标签都有一个统一的 src 属性
  

• 尺寸单位，可以通过 width宽度 和 height长度 控制资源大小

• src属性中，绝对路径和相对路径

超链接&列表标签

• a 超链接标签
  
• ol 有序列表标签， ul 无序列表标签

但是 ul 标签一般不赞成使用 type 属性，会用 css 样式取代

表格标签&布局标签

• table 标签中的 border 属性，设置整个表格边框的宽度； cellspacing 属性是设置单元格之间的空白，一般设置为 0 ；
• tr 标签中的 align 属性，设置单元格中内容行的对齐方式
  
• 布局标签 div 与 span 经常搭配 css 样式使用
  
• div 块级标签，这个标签占满一整行； span 行内标签，只占一小部分
  
  

表单标签（重点）

• form 表单标签就是用于采集用户输入的信息，然后将采集的信息发送到对应的服务端
  
  
• form 表单标签中的 action 属性是指定表单数据提交的URL；method 属性是指定表单提交的方式，默认提交方式为 GET。URL长度是有限制的，所以GET提交的数据有大小限制，而POST提交的数据没有大小限制
  
• 代码示例
  
• 我们可以看到在浏览器的地址栏的URL后拼接了我们提交的数据。username就是输入框name 属性值，而 hehe就是我们在输入框输入的内容。
  
• method = post，可以看到提交数据后不再拼接到URL后，通过浏览器开发者工具可以查看 hehe 数据提交到 http请求体中

表单项标签（重点）

• text 和 password 代码示例

• radio 单选框代码示例
  
  
  
• check 复选框，与radio使用方法类似，name值相同也可以进行多选，设置value是为了告诉后台选择了哪些选项
  
  
• 在开发者工具中看到的结果

• file 文件上传框代码示例

• hidden 隐藏提交，用户在修改信息时，有的内容不需要用户修改，但是每次也需要提交给后台，比如 后台数据库按 id 修改 操作时，id不需要用户提交。

• 浏览器页面不显示，但是可以通过开发者工具看到隐藏的提交信息，将标签中的 value值提交

• 提交、重置、普通按钮

• 重置按钮可以将 form 表单内选择好的数据全部清零，普通按钮需要配合JavaScript使用
  

• select 下拉列表 ，option 定义选项
  
  

• textarea 文本域
  
  
  

11.2 CSS

CSS介绍

CSS导入HTML三种方式

• 内联样式（不推荐使用，复用性很差）
  
• 内部样式
  
• 外部样式，link标签需要写在 head 标签内部，不是body内部
  

CSS选择器&属性（了解）

• 元素、id、.class类选择器
  
  
  
• 类选择器需要定义 id 属性并且每一个 id 属性必须唯一，同时 id 选择器需要在 id 前加#
  
  
• 类选择器需要定义 class 属性
  
  
  
• css属性参考 css相关网站学习
  css参考手册网站
  

11.3 JavaScript

JavaScript介绍

• JavaScript 和 Java 区别
• • 脚本语言：指不需要编译，直接解释运行，简化开发
    

两种引入方式

• 内部脚本，将 js 代码定义在 html 页面中
  
  
• 外部脚本，js 文件中不需要写 script 标签
  
• 引入外部 js 文件时，script 标签不可以自闭合
  

基础语法

输出语句

• HTML页面输出
  
  
• 浏览器控制台输出，输出的内容用浏览器自带的开发者工具查看
  
  

变量 var、let、const

• JavaScript是一门弱类型的语言，变量可以存放不同类型的值
  
• var 关键字，作用域：全局变量，可以重复定义
  
• let 关键字，变量只在关键字所在代码块有效，且不能重复定义
  
  
  
• const 关键字，声明常量，初始化赋值后不能再修改值
  

数据类型

• null 代表对象为空的占位符
  

运算符

• " == " 和 " === " 的区别
  

• 类型转换 string 类型转为 number 类型的两种方式

• number 里的特殊情况 NaN
  
  

• 类型转换 boolean 转为 number 类型，如果使用 paraseInt 的方法转换 number 类型，警告框会提示 NaN
  

• 其他类型转为 boolean 类型
  

• 其他类型转换为 boolean 类型，JavaScript自动类型转换可以应用到代码健壮性判断
  

• 总结
  

流程控制语句

• for 循环中变量使用 let，因为 var 是全局变量，可能被外部修改
  

函数（方法）

• function 关键字定义方法，推荐使用第二种通过一个 变量名 来定义一个函数方法
  

11.4 JavaScript对象

Array对象

• JavaScript 中的数组长度是可以变化的，没有复制的元素默认是undefined
  
• 属性 length数组长度
  
• 方法
  
  

String 对象

• trim（）函数
  
  

自定义对象

BOM对象

• Window对象的属性和函数（方法）
  
  
  
• confirm（）代码演示和实际应用场景
  
  
• 定时器方法代码示例和实际应用场景
• setTimeout（function（）{}，毫秒值），在一定时间间隔执行一次function方法，只会执行一次
• setInterval（function（）{}，毫秒值），在一定时间间隔只一次function方法，循环执行
  
• 例如京东商城首页面广告图，使用的就是setInterval方法，一直循环播放
  
• 定时器案例和实际用途
  
  
• 比如京东首页的广告图有 8 张，每过 3s 更换一次，就可以让if（）判断语句中 x%8==？ 产生8种结果，不停切换 8张 广告图

• History&Location对象
  
  
  
• 实际应用：注册成功后返回登录页面
  

DOM对象

• JavaScript 将 标记语言 各个组成部分 封装为对象
  
• DOM相关概念
  
• Element 4种获取方式，因为HTML的标签中 id 属性是唯一的，所以只会返回一个对象，其余的方式都是返回对象数组
  
• 获取 Element 对象四种方式代码示例
  
  
  
• JavaScript 通过 DOM 就能对 HTML 进行操作了
  
• 获取的 Element 对象都有属于自己的属性，可以查看相关文档使用对象
• img 元素对象的 src 属性可以把当前图片更改为其他图片
  
• innerHTML可以设置元素内容
  
• checked 属性为 true 就表示选项
• 会被选中
  

事件监听

• 事件绑定的两种方式，推荐使用第二种
  
  
• 第二种方式绑定事件代码示例
  
• 常见事件
  
• onblur 和 onfocus
  
  
• onsubmit 表单验证，一般用于用户注册，校验用户名是否合法，合法返回true，则用户名可以提交注册；不合法返回false，用户无法提交该用户名注册
  
  

11.5 表单验证（重点）

• 需求
  

• 需求分析：

• 1、输入框失去焦点，验证输入内容是否合法

• 2、 点击注册按钮，验证所有内容是否合法，不合法组织表单提交
  

• 验证输入框代码示例（用户名，密码，手机号通用格式）

• 注册提交时，验证所有输入框内容是否都符合要求代码示例

11.6 正则表达式（处理字符串）

• 正则表达式定义了字符串的组成规则
  
• 代码演示
  
• 校验手机号，要求第一个数字是1，只能由数字组成，总共11位数字