Java笔记26 - Spring开发 - 开发Web应用

JavaEE中Web开发的基础: Servlet
- Servlet规范定义了一种标准组件: Servlet, JSP, Filter和Listener;
- Servlet的标准组件总是运行在Servlet容器中, 如Tomcat, Jetty, WebLogic等
直接使用Servlet进行Web开发好比直接在JDBC上操作数据库, 比较繁琐
更好的方法是在Servlet基础上封装MVC框架, 基于MVC开发Web应用
Spring MVC足够我们不再去集成其他的框架.

使用Spring MVC

Servlet容器, 和标准的Servlet组件
- Servlet: 能处理HTTP请求并将HTTP响应返回;
- JSP: 一种嵌套Java代码的HTML, 将被编译为Servlet;
- Filter: 能过滤指定URL以实现拦截功能;
- Listener: 监听指定的事件, 如ServletContext, HttpSession的创建和销毁;
Servlet容器为每一个web容器自动创建一个唯一的ServletContext实例, 这个实例代表了Web应用程序本身

使用REST

集成Filter

<web-app>
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    ...
</web-app>

问题:
- 在Spring中创建一个AuthFilter是一个普通的Bean, Servlet容器不知道这个Bean的存在, 所以不会起作用
- 如果我们直接在web.xml中声明这个AuthFilter, 注意到AuthFilter的实例将由Servlet容器而不是Spring容器初始化
- 所以Autowire不会生效, 用于登录的UserService成员变量永远是null.
方法:
- 让Servlet容器实例化的Filter, 间接引用Spring容器实例化的AuthFilter.
- Spring MVC提供了一个DelegatingFilterProxy, 处理
原理:
- Servlet容器从web.xml中读取配置, 实例化DelegatingFilterProxy, 注意命名authFilter
- Spring容器通过扫描@Component实例化AuthFilter
- 当DelegatingFilterProxy生效后, 会自动查找注册在Servlet上的Spring容器.
- 再试图从容器中查找名为authFilter的Bean. 也就是我们用@Component声明的AuthFilter

    <filter>
        <filter-name>authFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>

    <!-- 指定Bean名字 -->
    <filter>
        <filter-name>basicAuthFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
        <!-- 指定Bean的名字 -->
        <init-param>
            <param-name>targetBeanName</param-name>
            <param-value>authFilter</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>authFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

代理模式应用:

┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐ ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
  ┌─────────────────────┐        ┌───────────┐   │
│ │DelegatingFilterProxy│─│─│─ ─>│AuthFilter │
  └─────────────────────┘        └───────────┘   │
│ ┌─────────────────────┐ │ │    ┌───────────┐
  │  DispatcherServlet  │─ ─ ─ ─>│Controllers│   │
│ └─────────────────────┘ │ │    └───────────┘
                                                 │
│    Servlet Container    │ │  Spring Container
 ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─   ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘

当一个Filter作为Spring容器管理的Bean存在时, 可以通过DelegatingFilterProxy简介的引用它, 并使其生效.

使用Interceptor

Filter2的拦截范围

         │   ▲
         ▼   │
       ┌───────┐
       │Filter1│
       └───────┘
         │   ▲
         ▼   │
       ┌───────┐
┌ ─ ─ ─│Filter2│─ ─ ─ ─ ─ ─ ─ ─ ┐
       └───────┘
│        │   ▲                  │
         ▼   │
│ ┌─────────────────┐           │
  │DispatcherServlet│<───┐
│ └─────────────────┘    │      │
   │              ┌────────────┐
│  │              │ModelAndView││
   │              └────────────┘
│  │                     ▲      │
   │    ┌───────────┐    │
│  ├───>│Controller1│────┤      │
   │    └───────────┘    │
│  │                     │      │
   │    ┌───────────┐    │
│  └───>│Controller2│────┘      │
        └───────────┘
└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘

Interceptor拦截范围: 不是后续整个处理流程, 而是仅针对Controller拦截.

       │   ▲
       ▼   │
     ┌───────┐
     │Filter1│
     └───────┘
       │   ▲
       ▼   │
     ┌───────┐
     │Filter2│
     └───────┘
       │   ▲
       ▼   │
┌─────────────────┐
│DispatcherServlet│<───┐
└─────────────────┘    │
 │              ┌────────────┐
 │              │ModelAndView│
 │              └────────────┘
 │ ┌ ─ ─ ─ ─ ─ ─ ─ ─ ┐ ▲
 │    ┌───────────┐    │
 ├─┼─>│Controller1│──┼─┤
 │    └───────────┘    │
 │ │                 │ │
 │    ┌───────────┐    │
 └─┼─>│Controller2│──┼─┘
      └───────────┘
   └ ─ ─ ─ ─ ─ ─ ─ ─ ┘

只拦截Controller方法, 返回ModelAndView后, 后续对View的渲染就脱离了interceptor的范围
Interceptor好处:
- 本身是Spring管理的Bean, 注入任意的Bean都很简单
- 可以应用多个Interceptor, 并通过简单的@Order指定顺序

@Order(1)
@Component
public class AuthInterceptor implements HandlerInterceptor{

  final Logger logger = LoggerFactory.getLogger(getClass());

  @Autowired
  UserService userService;

  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    logger.info("pre authenticate {}...", request.getRequestURI());
    try {
      authenticateByHeader(request);
    } catch (Exception e) {
      logger.warn("login by authorization header failed", e);
    }
    return true;
  }

  private void authenticateByHeader(HttpServletRequest req) {
    String authHeader = req.getHeader("Authorization");
    if (authHeader != null && authHeader.startsWith("Basic ")) {
      logger.info("try authenticate by authorization header");
      String up = new String(Base64.getDecoder().decode(authHeader.substring(6)), StandardCharsets.UTF_8);
      int pos = up.indexOf(":");
      if (pos > 0) {
        String email = URLDecoder.decode(up.substring(0, pos), StandardCharsets.UTF_8);
        String password = URLDecoder.decode(up.substring(pos + 1), StandardCharsets.UTF_8);
        User user = userService.signin(email, password);
        req.getSession().setAttribute(UserController.KEY_USER, user);
        logger.info("user {} login by authorization header ok", email);
      }
    }
  }
}

  @Bean
  WebMvcConfigurer createWebMvcConfigurer(@Autowired HandlerInterceptor[] interceptors) {
    return new WebMvcConfigurer() {
      @Override
      public void addInterceptors(InterceptorRegistry registry) {
        for (HandlerInterceptor interceptor : interceptors) {
          registry.addInterceptor(interceptor);
        }
      }

      @Override
      public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**").addResourceLocations("/static/");
      }
    };
  }

异常处理

  @ExceptionHandler(RuntimeException.class)
  public ModelAndView handleUnkAndView(Exception ex) {
    return new ModelAndView("500.html", Map.of("error", ex.getClass().getSimpleName(), "message", ex.getMessage()));
  }

可以编写多个错误处理方法, 每个方法针对特定的异常.
LoginException使得页面可以自动跳转到登录页.
ExceptionHandler仅作用于当前的Controller,

处理CORS

JavaScript和后端Api交互. 有很多安全限制.
默认情况下, 浏览器按同源策略放行JavaScript调用API:
- A站在域名a.com页面的js调用A的api, 没问题
- A站在域名b.com页面的js调用B站b.com的api, 被浏览器拒绝, 不满足同源策略
同源策略: 域名相同(a.com/www.a.com不同);协议相同(http/https不同);端口相同
办法: CORS: Cross-Origin Resource Sharing, HTML5规定的如何跨域访问资源
A站的js访问B站的api时, B站能够返回响应头Access-Control-Allow-Origin: http://a.com. 浏览器就运行访问;
跨域能否成功, 取决于B站是否愿意给A站返回一个正确的Access-Control-Allow-Origin

使用@CrossOrigin

@CrossOrigin(origins = "https://local.aaa.com:8080")
@RestController
@RequestMapping("/api")
public class AipController {
}

使用CorsRegistry

  WebMvcConfigurer createWebMvcConfigurer(@Autowired HandlerInterceptor[] interceptors) {
    return new WebMvcConfigurer() {
      @Override
      public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
        .allowedOrigins("http://sugar.k.sohu.com", "https://www.baidu.com")
        .allowedMethods("GET", "POST")
        .maxAge(3600);
      }
    }
  }

使用CorsFilter

需要配置web.xml, 不推荐.

国际化

  public static void main(String[] args) {
    double price = 123.5;
    int number = 10;
    Object[] arguments = {price, number};
    MessageFormat mfUS = new MessageFormat("Pay {0, number, currency} for {1} books.", Locale.US);
    System.out.println(mfUS.format(arguments));
    MessageFormat mfZH = new MessageFormat("{1}本书一共{0, number, currency}.", Locale.CHINA);
    System.out.println(mfZH.format(arguments));
  }

获取Locale

  @Bean
  LocaleResolver createLocalResolver() {
    CookieLocaleResolver clr = new CookieLocaleResolver();
    clr.setDefaultLocale(Locale.ENGLISH);
    clr.setDefaultTimeZone(TimeZone.getDefault());
    return clr;
  }

首先根据特定的Cookie判断是否指定了Local
如果没有, 就从HTTP头获取, 如果还没有, 就返回默认的Local
用户第一次访问网帐时, CookieLocalResolver只能从HTTP头获取Local. 浏览器默认使用的语言
网站让用户选择自己的语言, 此时, CookieLocaleResolver就会把用户选择的语言存放在Cookie中.

提取资源文件

第二步: 把写死在模板中字符串以资源文件的方式存储在外部.

创建MessageSource

第三步: 创建一个Spring提供的MessageSource实例, 自动读取.properties文件.
并提供一个统一的接口来实现翻译
真费劲.. 越到后面越不想学, 越想写自己的项目.. 还有最后一节课. 搞定一个聊天室就ok了. 美滋滋

异步处理

在Servlet模型中, 每个请求都是由某个线程处理, 然后将响应写入IO流, 发送给客户端.
从开始处理请求, 到写入响应完成, 都是同一个线程中处理.
实现Servlet容器, 只要每处理一个请求, 就创建一个新线程处理它, 就能保证正确实现了Servlet线程模型.
例如Tomcat, 总是通过线程池来处理请求, 仍然符合一个请求从头到尾都由某一个线程处理
线程模型非常重要, 因为Spring的JDBC事务是基于ThreadLocal实现.
很多安全认证也是基于ThreadLocal实现, 可以保证在处理请求的过程中, 各个线程互不影响.
如果请求处理的时间很长, 基于线程池的同步模型很快就回把所有线程耗尽, 导致服务器无法响应新的请求.
如果长时间处理的请求改为异步, 线程池的利用率就会大大提高.
Servlet从3.0开始添加了异步支持, 允许对一个请求进行异步处理.
和不同的MVC程序相比, web.xml不同:
- 声明对Servlet3.1规范的支持
- 对DispatcherServlet的配置多了一个<async-supported>
配置web.xml

  @GetMapping("/users")
  public Callable<List<User>> users() {
    return () -> {
      try {
        Thread.sleep(3000);
      } catch (Exception e) {
      }
      return userService.getUsers();
    };
  }

  @GetMapping("/user/{id}")
  public DeferredResult<User> user(@PathVariable("id") long id) {
    DeferredResult<User> result = new DeferredResult<>(3000L); // 3秒超时
    new Thread(() -> {
      try {
        Thread.sleep(1000);
      } catch (Exception e) {
      }
      try {
        User user = userService.getQueryById(id);
        result.setResult(user);
      } catch (Exception e) {
        result.setErrorResult(Map.of("error", e.getClass().getSimpleName(), "message", e.getMessage()));
      }
    }).start();
    return result;
  }

使用DeferredResult, 可以设置超时, 正常结果和错误结果.
使用async处理异步响应时, 要牢记, 在另一个线程中的事务和Controller方法执行的事物不是同一个事务.
在Controller中绑定的ThreadLocal信息也无法在异步线程中获取.

Servlet3.0规范添加的异步支持是针对同步模型打了一个补丁. 虽然可以异步处理请求, 但在高并发异步请求时, 效率不高.
因为没有真正用到原生异步. Java标准库封装了操作系统的异步IO包java.nio, 是真正的多路复用IO模型, 可以用少量线程支持大量并发.
NIO编程复杂高, 很少直接也能够. 可以选用Netty框架.

使用WebSocket

WebSocket是一种基于HTTP的长连接技术.
传统的HTTP协议, 是一种请求-响应模型, 如果浏览器不发送请求, 那么服务器无法主动给浏览器推送数据.
基本靠轮询.
HTTP本身基于TCP连接的, WebSocket在HTTP协议上做了一个简单的升级, 即建立TCP连接后, 浏览器发送请求, 附带:

GET /chat HTTP/1.1
Host: www.example.com
Upgrade: websocket
Connection: Upgrade

表示客户端希望升级连接, 变成长连接的WebSocket, 服务器返回升级成功的响应:

Http/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade

收到成功响应后表示WebSocket握手成功, 这样, 代表WebSocket的这个TCP连接将不会被服务器关闭, 而是一直保持.
两步:
- 嵌入式Tomcat支持WebSocket的组件
- Spring封装的支持WebSocket的接口
加入配置

  @Bean
  WebSocketConfigurer createWebSocketConfigurer(@Autowired ChatHandler chatHandler,
      @Autowired ChatHandshakeInterceptor catInterceptor) {
    return new WebSocketConfigurer() {
      @Override
      public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        // 把URL与指定的WebSocketHandler关联, 可关联多个
        registry.addHandler(chatHandler, "/chat").addInterceptors(catInterceptor);
      }
    };
  }

关键实现能处理WebSocket的handler, 和可选的WebSocket拦截器
TextWebSocketHandler和BinaryWebSocketHandler分别处理文本消息和二进制消息.
我们选择文本消息作为聊天室协议, 所以ChatHandler继承TextWebSocketHandler

@Component
public class ChatHandler extends TextWebSocketHandler {

  private final Logger logger = LoggerFactory.getLogger(getClass());

  @Autowired
  ChatHistory chatHistory;

  @Autowired
  ObjectMapper objectMapper;

  // 保存所有Client的WebSocket会话实例
  private Map<String, WebSocketSession> clients = new ConcurrentHashMap<>();

  // 传播消息
  public void broadcastMessage(ChatMessage chat) throws IOException {
    // 首先拿到消息
    TextMessage message = toTextMessage(List.of(chat));
    // 取到所有客户端的session id
    for (String id : clients.keySet()) {
      WebSocketSession session = clients.get(id);
      session.sendMessage(message);
    }
  }

  // 处理消息
  @Override
  protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
    String s = message.getPayload().strip();
    if (s.isEmpty()) {
      return;
    }
    String name = (String) session.getAttributes().get("name");
    ChatText chat = objectMapper.readValue(s, ChatText.class);
    ChatMessage msg = new ChatMessage(name, chat.text);
    // 添加到历史记录
    chatHistory.addToHistory(msg);
    // 广播消息
    broadcastMessage(msg);
  }

  // 开启连接的时候
  @Override
  public void afterConnectionEstablished(WebSocketSession session) throws JsonProcessingException, IOException {
    // 新会话根据id放入Map
    clients.put(session.getId(), session);
    String name = null;
    // 根据session获取用户信息
    User user = (User) session.getAttributes().get("__user__");
    if (user != null) {
      name = user.getName();
    } else {
      name = initGuestName();
    }
    session.getAttributes().put("name", name);
    logger.info("websocket connection established: id = {}, name = {}", session.getId(), name);
    // 把历史消息发送给新用户
    List<ChatMessage> list = chatHistory.getHistory();
    session.sendMessage(toTextMessage(list));
    // 添加系统消息并广播
    ChatMessage msg = new ChatMessage("SYSTEM MESSAGE: ", name + " joined the room");
    chatHistory.addToHistory(msg);
    broadcastMessage(msg);
  }

  @Override
  public void afterConnectionClosed(WebSocketSession session, CloseStatus status) {
    clients.remove(session.getId());
    logger.info("websocket connection closed: id = {}, close-status = {}", session.getId(), status);
  }

  private TextMessage toTextMessage(List<ChatMessage> messages) throws JsonProcessingException {
    String json = objectMapper.writeValueAsString(messages);
    return new TextMessage(json);
  }

  private String initGuestName() {
    return "Guest" + this.guestNumber.incrementAndGet();
  }

  private AtomicInteger guestNumber = new AtomicInteger();
}

我们需要从http的session中复制信息到 websocket session

@Component
public class ChatHandshakeInterceptor extends HttpSessionHandshakeInterceptor {
  public ChatHandshakeInterceptor() {
    // 指定HttpSession复制属性到WebSocketSession
    super(List.of(UserController.KEY_USER));
  }
}

浏览器中js连接websocket的方法

    var ws = new WebSocket('ws://' + location.host + '/chat');
    // 连接打开
    ws.addEventListener('open', function (event) {
    });
    // 收到消息
    ws.addEventListener('message', function (event) {
    });
    // 连接关闭
    ws.addEventListener('close', function () {
    });
    // 绑定全局
    window.chatWs = ws;

posted @ 2021-02-03 15:51 张润昊阅读(169) 评论(0) 编辑收藏举报

刷新页面返回顶部

张润昊的博客

每一个不曾起舞的日子,都是对生命的辜负.

Java笔记26 - Spring开发 - 开发Web应用

使用Spring MVC

使用REST

集成Filter

使用Interceptor

异常处理

处理CORS

使用@CrossOrigin

使用CorsRegistry

使用CorsFilter

国际化

获取Locale

提取资源文件

创建MessageSource

异步处理

使用WebSocket

公告