一、集合

1.1 Collection接口

Collection是集合框架中最基础的父接口，可以存储无序、不唯一的对象。

Iterable专门用来迭代，把集合中的元素全部取出来

Collection 中所有元素可以通过Iterator进行迭代（List、Set)

• Collection常用方法

方法	描述
int size()	获取集合长度
boolean isEmpty()	判断集合是否为空
boolean contains(Object o)	判断集合中是否包含某个元素
Iterator<E> iterator()	实例化Iterator接口，遍历集合
Object[] toArray()	将集合转换为一个Object类型的对象数组
boolean add(E e)	向集合中添加元素
boolean remove(Object o)	从集合中移除元素
boolean containsAll(Collection c)	判断集合中是否存在某个集合的所有元素
boolean addAll(Collection c)	向集合中添加某个集合的所有元素
boolean removeAll(Collection c)	从集合中移除满足条件的另一个集合
void clear()	清空集合
boolean equals(Object o)	比较两个集合是否相等
int hashCode()	获取集合对象的散列值

1.2 Collection的子接口

使用其子接口

• List：存放有序、不唯一的元素
• Set:存放无序、唯一的元素
• Queue:队列接口

1.3 List接口

List接口在继承Collection接口的基础上进行了扩展，常用的扩展方法

方法	描述
E get(int index)	通过下标获取集合中指定位置的元素
E set(int index,E element)	替换集合中指定位置的元素
void add(int index,E element)	向集合中的指定位置添加元素
E remove(int index)	通过下标删除集合中指定位置的元素
int indexOf(Object o)	查找某个对象在集合中的下标
int lastIndexOf(Object o)	从后向前查找某个对象在集合中的下标
ListIterator<E> listIterator()	实例化ListIterator接口
List<E> subList(int fromIndex,int toIndex)	获取集合中的子集合

1.4 List接口的实现类

ArrayList实现了长度可变的数组

优点：查找快，因为元素都是连续的，可以快速求出下标从而取出元素

缺点：增删慢，因为元素都是连续的，添加一个元素，就必须先将后续的元素依次后移一位，再把新元素加入，删除同理。

import java.util.ArrayList;

public class Test5 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("Hello");
        list.add("World");
        list.add("Love");
        list.add("You");
        System.out.println(list);
    }
}

调用的是toString方法，源码如下：

  public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }

LinkedList 采用链表的形式来存储数据，和ArrayList恰好相反

优点：增删快

缺点：查询慢

地址指向，元素不连续。

import java.util.ArrayList;
import java.util.LinkedList;

public class Test5 {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("Hello");  //向集合中添加元素
        list.add("World");
        list.add("Java");
        System.out.println(list);
        list.offer("JavaSE"); //向集合中添加元素，向后添加
        list.offer("JavaEE");
        System.out.println(list);
        list.push("JavaME"); //向集合中添加元素，从0开始添加
        System.out.println(list);
        list.addFirst("JavaEE2");//从前开始添加元素
        System.out.println(list);
        System.out.println(list.peekFirst());//获取集合中第一个元素
        System.out.println(list.peekLast());//获取集合中最后一个元素
        System.out.println(list);
        System.out.println(list.pollFirst()); //获取集合中第一个元素并删掉
        System.out.println(list.pollLast());//获取集合中最后一个元素并删掉
        System.out.println(list);
    }
}

二、Spring

2.1 AOP

Aspect Oriented Programming 面向切面编程

Object Oriented Programming 面向对象编程

将程序中所有参与模块都抽象成对象，然后通过对象之间的相互调用完成特定的功能。

AOP是对OOP的一种补充，是在另外一个维度上抽象出对象，具体是指程序运行时动态将非业务代码切入到业务代码中，实现了业务代码和非业务代码的解耦合。

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.31</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.3.31</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.3.31</version>
    </dependency>

package com.myspring.aop;

public interface Cal {
    public int add(int num1, int num2);
    public int sub(int num1,int num2);
    public int mul(int num1,int num2);
    public int div(int num1,int num2);
}

package com.myspring.aop;

import org.springframework.stereotype.Component;

@Component
public class CalImpl implements Cal{
    @Override
    public int add(int num1, int num2) {
//        System.out.println("add的参数是" + num1 + "," + num2);  //非业务代码
        int result = num1 + num2;//业务代码
//        System.out.println("add方法的结果是" + result);  //非业务代码
        return result;
    }

    @Override
    public int sub(int num1, int num2) {
        int result = num1 - num2;
        return result;
    }

    @Override
    public int mul(int num1, int num2) {
        int result = num1 * num2;
        return result;

    }

    @Override
    public int div(int num1, int num2) {
     int result = num1 / num2;
     return  result;
    }
}

package com.myspring.aop;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.Objects;

@Component
@Aspect
@EnableAspectJAutoProxy   //生成动态代理
public class LoggerAspect {
    /**
     * 参数日志
     */
//    @Before("execution(public int com.myspring.aop.CalImpl.add(..))")  //此时只对add方法生效
    @Before("execution(public int com.myspring.aop.CalImpl.*(..))")  //此时CalImpl中所有方法皆可输出
    public void before(JoinPoint joinPoint){
      String name =  joinPoint.getSignature().getName();
      String args = Arrays.toString(joinPoint.getArgs());
        System.out.println(name + "的参数是" + args);
    }

    /**
     * 结果日志
     */
    @AfterReturning(value = "execution(public int com.myspring.aop.CalImpl.*(..))",returning = "result")
    public void afterReturn(JoinPoint joinPoint, Object result){
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法的结果是" + result);
    }
}

package com.myspring.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test {
    public static void main(String[] args) {
//        Cal cal = new CalImpl();
//        System.out.println(cal.add(10, 1));
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext("com.myspring.aop");
        Cal cal = (Cal) applicationContext.getBean("calImpl");
        System.out.println(cal.add(1, 1));
        System.out.println(cal.sub(5, 2));
        System.out.println(cal.mul(3, 8));
        System.out.println(cal.div(10, 2));
    }
}

AOP基于IoC,将业务对象和切面对象分别注入到IoC中，同时业务对象只写业务代码，切面对象只写非业务代码，从而在代码层面实现业务代码和非业务代码的解耦合效果，通过IoC再将业务代码和非业务代码整合到一起即可，开发时解耦，运行时合并。

如何整合？

通过代理对象，将业务对象注入到IoC中，将切面对象也注入到IoC中，由IoC负责根据业务对象和切面对象创建出一个动态的代理对象，分别去完成业务代码和非业务代码的执行。

• 业务对象和切面对象必须注入到IoC中
• 切面对象需要添加切面注解以及动态代理注解  @Aspect @EnableAspectJAutoProxy

三、Spring MVC

Spring MVC是Spring全家桶的一款产品，对Java Web开发流程进行了封装，不需要再通过Servlet的方式来完成代码的开发，无论是代码量还是参数的接收，返回值等等各方面都做了优化。

Spring MVC是基于Spring框架的，基于IoC容器

Servlet：创建一个Servlet,接收客户端请求，完成相关的业务操作。

3.1 Spring MVC的使用

1.引入Spring MVC的依赖

 <!--引入spring mvc的依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.31</version>
    </dependency>

2.web.xml文件中配置springmvc

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>
  <!--Spring MVC的前端控制器-->
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springmvc.xml</param-value>
  </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

3.创建springmvc配置文件

<?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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd">

   
 <!-- 启用注解驱动，必须要有。Spring MVC 的 @RequestMapping 注解。
    需要 <mvc:annotation-driven/> 来启用注解驱动的处理器映射和适配器。
    没有它，Spring 根本不认识你的 @Controller 和 @RequestMapping-->
    <mvc:annotation-driven />


 <!-- 扫包 -->
    <context:component-scan base-package="com.myspring.controller"/>

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

4.创建控制器

package com.myspring.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {
    @RequestMapping("/index")
    public String index(){
        System.out.println("index......");
        return "index";
    }
}

3.2 Spring MVC传参数

Spring MVC会自动对request中的参数进行解析，类型转换。开发者只需要在方法定义处声明需要的参数类型格式，Spring MVC会自动对参数进行解析和转换。

3.3 Spring MVC 返回

• 视图

    定义方法返回值类型为String,返回视图名称，同时结合视图解析器，将真正的视图资源返回给调用者。

• JSON数据

    需要在方法定义处添加@RequestBody,方法中直接返回数据即可。

返回试图是前后端不分离的单体架构，返回JSON数据前后端分离的架构。

3.4 单体架构

• 返回视图
• 将业务数据同时带到前端

package com.myspring.controller;
import com.myspring.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HelloController {
    @RequestMapping("/index")
    public String index(Model model){
        User user = new User();
        user.setId(1);
        user.setName("李四");
        model.addAttribute("name","张三");
//        model.addAttribute("user","User");	//String  没有 id/name 属性
        model.addAttribute("user",user);  //正常访问 ${user.id} 和 ${user.name}
        return "index";
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page isELIgnored="false"%><!--可以把视图上的{name}转换成对应的值“张三”-->
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>${name}</h1>
<h2>${user.id}</h2>
<h2>${user.name}</h2>

</body>
</html>

四、MyBatis

MyBatis是ORM框架

4.1 pom.xml

<dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.33</version>
    </dependency>
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.4.5</version>
    </dependency>

4.2 config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 配置项 -->
    <settings>
        <!--打印SQL-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <!--MySQL 8.0 要用 com.mysql.cj.jdbc.Driver，不是 com.mysql.jdbc.Driver-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/car_rental_separate"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/myspring/mapper/NewsMapper.xml"></mapper>
    </mappers>
</configuration>

4.3 创建实体类

package com.myspring.entity;

import lombok.Data;

import java.util.Date;

@Data
public class News {
    private int id;
    private String title;
    private Date createtime;
    private String opername;
    private String content;
}

4.4 创建Mapper接口

package com.myspring.mapper;

import com.myspring.entity.News;

public interface NewsMapper {
    public int add(News news);
}

4.5 接口对应的mapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.myspring.mapper.NewsMapper">

    <!-- 你的映射语句 -->
    <insert id="add" parameterType="com.myspring.entity.News">
        insert into sys_news(title,content,createtime,opername) values (#{title},#{content},#{createtime},#{opername})
    </insert>

</mapper>

4.6 使用

package com.myspring;

import com.myspring.entity.News;
import com.myspring.mapper.NewsMapper;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;
import java.util.Date;

public class Test1 {
    public static void main(String[] args) {
        InputStream resourceAsStream = Test1.class.getClassLoader().getResourceAsStream("config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = builder.build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取Mapper的代理对象
        NewsMapper mapper = sqlSession.getMapper(NewsMapper.class);
        News news = new News();
        news.setTitle("测试");
        news.setCreatetime(new Date());
        news.setOpername("admin");
        news.setContent("测试测试测试");
        int add = mapper.add(news);
        System.out.println(add);
        sqlSession.commit();//提交到数据库
    }
}

也可以将SQL直接添加到业务方法上

package com.myspring.mapper;

import com.myspring.entity.News;
import org.apache.ibatis.annotations.Insert;

public interface NewsMapper {
    @Insert({"insert into sys_news(title,content,createtime,opername) values (#{title},#{content},#{createtime},#{opername})"})
    public int add(News news);
}