1 Spring

SpringBoot项目并不是替换Spring、SpringMVC，而是使他们用起来更加简单

1.1 Spring框架最核心的特性一依赖注入DI（控制反转IOC）

1.1.1 依赖注入的核心注解

@Component 最底层注解，依赖注入默认扫描的类型
@ResponseBody 返回数据json数据
@RequestBody 参数是json数据

下面接口都继承了@Component，在扫描解析@ComponentScan时会收集
@Repository dao层注解 （代码中是直接指定了包，没有使用注解也可以扫描接口）
@Service service层注解
@Controller controller层对外接口注解
@RestController @ResponseBody 与 @Controller 的组合体 ，对外接口返回json数据

@Autowired 最常用的注入注解 byName,byType
@Resource 注入注解 byName
@Qualifier 与@Resource配合使用，解决byType重复的问题

1.1.2 注解的使用

注解使用起来很简单，在需要注入的地方使用写上注解就可以，默认是单例。
image.png
image.png

1.2 Spring框架最核心的特性二 AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1.2.1 AOP的应用场景如下

Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading　懒加载
Debugging　　调试
logging, tracing, profiling and monitoring　记录跟踪　优化　校准
Performance optimization　性能优化
Persistence　　持久化
Resource pooling　资源池
Synchronization　同步
Transactions 事务

1.2.2 AOP的使用概念

代理 注入的类被动态代理 （jdk、cglib动态代理，jdk要实现接口，cglib不实现接口也可以代理）
切面 使用注解@Pointcut 可以理解为切西瓜的第一刀

切点
@Around 环绕通过，可以实现下面注解的所有功能
@Before
@After 最终通知
@AfterReturning 返回结果通知
@AfterThrowing 发生的异常通知

事务处理，现在spring5已经封装的很好了，要看底层原码才行，这里用日志打印来讲解AOP

示例1：

1.2.2.1 引入AOP包

  1.         <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-aop</artifactId>
  4.         </dependency>

1.2.2.2 核心代码

  1. package com.alpaak.hellospringboot.utils.log;
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.serializer.SerializerFeature;
  5. import com.alpaak.hellospringboot.utils.IPUtil;
  6. import org.aspectj.lang.ProceedingJoinPoint;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.annotation.Pointcut;
  10. import org.aspectj.lang.reflect.MethodSignature;
  11. import org.slf4j.Logger;
  12. import org.slf4j.LoggerFactory;
  13. import org.springframework.stereotype.Component;
  14. import org.springframework.web.context.request.RequestContextHolder;
  15. import org.springframework.web.context.request.ServletRequestAttributes;
  17. import javax.servlet.http.HttpServletRequest;
  18. import javax.servlet.http.HttpServletResponse;
  19. import java.time.LocalDateTime;
  20. import java.util.Enumeration;
  21. import java.util.Objects;
  23. /**
  24.  * @ClassName: ReqLogAspect
  25.  * @Description: 请求日志
  26.  * @author: Alpaak
  27.  * @date: 2021/07/08 15:38
  28.  */
  30. @Aspect
  31. @Component
  32. public class ReqLogAspect {
  34.     private static final Logger LOGGER = LoggerFactory.getLogger(ReqLogAspect.class);
  36.     private final static String REQ_TYPE_FILE = "file";
  37.     private final static String REQ_TYPE_FILES = "files";
  39.     @Pointcut("execution(* com.alpaak.hellospringboot.controller..*(..))")
  40.     public void controller() {
  41.     }
  44.     @Around("controller()")
  45.     public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
  46.         //记录请求开始执行时间：
  47.         long beginTime = System.currentTimeMillis();
  49.         RequestInfo request = resolve(pjp);
  50.         //记录日志
  51.         LOGGER.info("请求开始!\n{}", request);
  52.         Object result = pjp.proceed();
  54.         //请求操作成功
  55.         String resultJson = "";
  56.         if (result != null) {
  57. //            if (result instanceof Result) {
  58. //                resultJson = JSON.toJSONString(result, SerializerFeature.WriteDateUseDateFormat);
  59. //            } else {
  60. //                resultJson = String.valueOf(result);
  61. //            }
  62.             resultJson = JSON.toJSONString(result, SerializerFeature.WriteDateUseDateFormat);
  63.         }
  65.         //记录请求完成执行时间：
  66.         long endTime = System.currentTimeMillis();
  67.         long usedTime = endTime - beginTime;
  69.         //记录日志
  70.         LOGGER.info("{} \n请求成功! 耗时:[{}]ms.", resultJson, usedTime);
  72.         // TODO Save to DB
  73.         return result;
  74.     }
  76.     private RequestInfo resolve(ProceedingJoinPoint pjp) {
  77.         //获取请求信息
  78.         ServletRequestAttributes sra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
  79.         HttpServletRequest request = Objects.requireNonNull(sra).getRequest();
  81.         Enumeration<String> headerNames = request.getHeaderNames();
  82.         StringBuilder headers = new StringBuilder();
  83.         while (headerNames.hasMoreElements()) {
  84.             headers.append(headerNames.nextElement()).append(",");
  85.         }
  86.         LOGGER.debug("====> Headers: {}", headers.toString());
  88.         //获取代理地址、请求地址、请求类名、方法名
  89.         //获取请求参数
  90.         MethodSignature ms = (MethodSignature) pjp.getSignature();
  91.         //获取请求参数类型
  92.         String[] parameterNames = ms.getParameterNames();
  93.         //获取请求参数值
  94.         Object[] parameterValues = pjp.getArgs();
  95.         StringBuilder params = new StringBuilder();
  96.         //组合请求参数，进行日志打印
  97.         if (parameterNames != null && parameterNames.length > 0) {
  98.             for (int i = 0; i < parameterNames.length; i++) {
  99.                 String name = parameterNames[i];
  100.                 if ("bindingResult".equals(name)) {
  101.                     break;
  102.                 }
  104.                 // 文件
  105.                 if (REQ_TYPE_FILE.equals(name.toLowerCase()) ||
  106.                         REQ_TYPE_FILES.equals(name.toLowerCase())) {
  107.                     continue;
  108.                 }
  110.                 Object value = parameterValues[i];
  111.                 if ((value instanceof HttpServletRequest) || (value instanceof HttpServletResponse)) {
  112.                     params.append("{").append(name).append(":").append(value).append("}");
  113.                 } else {
  114.                     params.append("{").append(name).append(":")
  115.                             .append(JSON.toJSONString(value, SerializerFeature.WriteDateUseDateFormat))
  116.                             .append("}");
  117.                 }
  118.             }
  119.         }
  121.         final RequestInfo.RequestInfoBuilder builder = RequestInfo.builder()
  122.                 .date(LocalDateTime.now().toString())
  123.                 .address(IPUtil.getClientIp(request))
  124.                 .uri(request.getRequestURI())
  125.                 .method(request.getMethod())
  126.                 .clazz(pjp.getTarget().getClass().getSimpleName() + "->" + pjp.getSignature().getName())
  127.                 .params(params.toString());
  129. //        Optional.ofNullable(UserUtils.getUser())
  130. //                .ifPresent(user -> builder.user(user.getName()));
  132.         return builder.build();
  133.     }
  135.     static class RequestInfo {
  136.         String client;
  137.         String user;
  138.         String address;
  139.         String uri;
  140.         String clazz;
  141.         String method;
  142.         String params;
  143.         String date;
  146.         private RequestInfo(RequestInfoBuilder b) {
  147.             this.client = b.client;
  148.             this.user = b.user;
  149.             this.address = b.address;
  150.             this.uri = b.uri;
  151.             this.clazz = b.clazz;
  152.             this.method = b.method;
  153.             this.params = b.params;
  154.             this.date = b.date;
  155.         }
  157.         public static RequestInfoBuilder builder() {
  158.             return new RequestInfoBuilder();
  159.         }
  161.         @Override
  162.         public String toString() {
  163.             return String.format(
  164.                     "%s %s\n==>|PARAMS：%s\n==>|IP: %s;\n==>|CLIENT: %s\n==>|USER: %s\n==>|CONTROLLER：%s\n==>|DATE: %s",
  165.                     method, uri, params, address, client, user, clazz, date
  166.             );
  167.         }
  170.         public static class RequestInfoBuilder {
  171.             String client;
  172.             String user;
  173.             String address;
  174.             String uri;
  175.             String clazz;
  176.             String method;
  177.             String params;
  178.             String date;
  180.             private RequestInfoBuilder() {
  181.             }
  183.             public RequestInfoBuilder client(String client) {
  184.                 this.client = client;
  185.                 return this;
  186.             }
  188.             public RequestInfoBuilder user(String user) {
  189.                 this.user = user;
  190.                 return this;
  191.             }
  193.             public RequestInfoBuilder address(String address) {
  194.                 this.address = address;
  195.                 return this;
  196.             }
  198.             public RequestInfoBuilder uri(String uri) {
  199.                 this.uri = uri;
  200.                 return this;
  201.             }
  203.             public RequestInfoBuilder clazz(String clazz) {
  204.                 this.clazz = clazz;
  205.                 return this;
  206.             }
  208.             public RequestInfoBuilder method(String method) {
  209.                 this.method = method;
  210.                 return this;
  211.             }
  213.             public RequestInfoBuilder params(String params) {
  214.                 this.params = params;
  215.                 return this;
  216.             }
  218.             public RequestInfoBuilder date(String date) {
  219.                 this.date = date;
  220.                 return this;
  221.             }
  223.             public RequestInfo build() {
  224.                 return new RequestInfo(this);
  225.             }
  226.         }
  227.     }
  229. }
package com.alpaak.hellospringboot.utils.response;

/**
 * @ClassName: GlobalConstant
 * @Description: 全局常量定义
 */
public class GlobalConstant {

    // 返回状态
    public static final String RET_STATUS = "status";
    // 交互成功状态
    public static final int SUCCESS = 1;
    // 交互失败状态
    public static final int ERROR = 0;
    //未登陆code
    public static final int NO_LOGIN = 401;

}

package com.alpaak.hellospringboot.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Enumeration;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * IPUtil
 *
 * @author alpaak  ip的通用工具类
 * @version 1.0
 * @date 2021/4/2 18:56
 */
public class IPUtil {

    private static final Logger log = LoggerFactory.getLogger(IPUtil.class);

    private final static String UNKNOWN = "unknown";


    /**
     * 检查IP是否合法
     *
     * @param ip -
     * @return boolean
     */
    public static boolean valid(String ip) {
        String regex0 = "(2[0-4]\\d)" + "|(25[0-5])";
        String regex1 = "1\\d{2}";
        String regex2 = "[1-9]\\d";
        String regex3 = "\\d";
        String regex = "(" + regex0 + ")|(" + regex1 + ")|(" + regex2 + ")|(" + regex3 + ")";
        regex = "(" + regex + ").(" + regex + ").(" + regex + ").(" + regex + ")";
        Pattern p = Pattern.compile(regex);
        Matcher m = p.matcher(ip);
        return m.matches();
    }

    /**
     * 获取本地ip 适合windows与linux
     *
     * @return String
     */
    public static String localIP() {
        try {
            Enumeration netInterfaces = NetworkInterface.getNetworkInterfaces();
            while (netInterfaces.hasMoreElements()) {
                NetworkInterface ni = (NetworkInterface) netInterfaces.nextElement();
                try {
                    InetAddress ip = ni.getInetAddresses().nextElement();
                    if (!ip.isLoopbackAddress() && ip.getHostAddress().indexOf(":") == -1) {
                        return ip.getHostAddress();
                    }
                } catch (Exception e) {
                    log.warn(e.getMessage());
                }
            }
        } catch (SocketException e) {
            log.warn(e.getMessage());
            try {
                return InetAddress.getLocalHost().getHostAddress();
            } catch (UnknownHostException e1) {
                log.warn(e1.getMessage());;
            }
        }

        return  "127.0.0.1";
    }

    /**
     * 获取客户机的ip地址
     *
     * @param request -
     * @return String
     */
    public static String getClientIp(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getHeader("http_client_ip");
        }
        if (ip == null || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        // 如果是多级代理，那么取第一个ip为客户ip
        if (ip != null && ",".indexOf(ip) != -1) {
            ip = ip.substring(ip.lastIndexOf(",") + 1).trim();
        }
        return ip;
    }


    /**
     * 把ip转化为整数
     *
     * @param ip -
     * @return long
     */
    public static long toInt(String ip) {
        String[] intArr = ip.split("\\.");
        int[] ipInt = new int[intArr.length];
        for (int i = 0; i < intArr.length; i++) {
            ipInt[i] = new Integer(intArr[i]);
        }
        return ipInt[0] * 256 * 256 * 256 + +ipInt[1] * 256 * 256 + ipInt[2] * 256 + ipInt[3];
    }

    public static void main(String[] args) {
        System.out.println(localIP());
    }

}

  1. Spring MVC提供了一种友好的方式来开发Web应用程序，可以轻松开发web

  2. Spring 和 Spring MVC最大的弊病在于重量级的配置，并且这些配置有很高的相似性。

  3. Spring Boot期望通过结合自动配置和启动器来解决模板化问题

  4. Spring Boot提供了丰富的第三方集成，简化开发体验

    2 SpringMVC

    SpringBoot项目并不是替换Spring、SpringMVC，而是使他们用起来更加简单
    springmvcv.png

    1 dao层，service层，controller层

如果去饭店吃饭，不可能找厨师点菜吧？小工负责食材存取，洗菜切肉；厨师负责烹饪；跑堂负责接待食客并与后厨沟通。这就是精典的分层体现。
如果一个厨师既负责跑堂，又负责烹饪。那这个饭店的管理一定非常混乱吧。小工就是DAO，从食材库里（数据源）取出食材（原始数据），进行简单处理（数据对象化）。厨师就是Service，找到小工（DAO），获取各种半成品（对象化数据），加工成顾客需要的菜肴（最终数据）。跑堂就是Controller，负责接单（提交数据）上菜（响应数据），是顾客与后厨间的媒介（提供用户与后台程序的接口）。各司其职（高内聚），轻松协作（低耦合），就是分层思想的目标。

1.1 dao层

与数据库打交道，提供原始数据，我们使用mybatis-plus + spring解决

1.2 service 层

承上启下，上接controller下接dao，spring解决

1.3 controller层

接收请求，反馈结果，springmvc解决

2 视图层，又可以称为前端，现在前后分离，后端提供数据，前端进行展示

前端可以是web页面、手机端、平板电脑端