Spring 使用经验谈

我会带着你远行 2022-10-19 12:42 172阅读 0赞

首先说说大潮流的 Spring Boot。因为项目强制要求的缘故，我不得不将 Spring 升级到 Spring Boot，但我个人觉得，这不但没有必要（不是做微服务），而且有以下几个问题：

*  Boot 采用新的的打包机制，默认生成一个体积非常大的 jar 包。这样导致更新很麻烦，每次上次那么大的 jar 耗时间久（lib 下面的依赖 jar）。以前我更新项目有个技巧，也不是用 war 包（第一次的时候可以是），而是同步本地的到远程的即可，因为本地事实的就是最终编译结果，通过 SFTP 同步两边即可。或者不同步，你知道更新哪个 class/jsp 上传文件即可，名副其实的“增量更新”。现在可好了——上传完整的 jar 包就是“全量更新” 。
 *  同样也正是这个原因，更加网页的静态文件非常不方便。——难道我改 HTML 里面的一个字符就要重新打包 jar 并上传？太不科学了吧！？
 *  由于 Boot 整合了 Tomcat 服务器，那些日志我都不知道哪里看，有肯定是有——那就要重新学习、改变习惯呗。以前的话，用 Tomcat 自带的脚本： `catalina.sh run` 就可以观察日志，非常方便。

![增量更新后台][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neGluMDk_size_16_color_FFFFFF_t_70]

当然，鼎鼎大名的 Boot 不是没有对应的解决方法，百度一下就有了。但鄙人就觉得不太优雅去处理咯。首先 `lib/*.jar` 可外置游离于 `WEB-INF/lib` 下面，依靠 Java 层面去指定某个目录，一个项目没啥事，多个项目呢？——这个就花费了人们去管理这个目录的“心智”；其次，前台页面的，也可以游离出去，不是放在 `webapps` 下面，所以管理维护成本又上升了——我何必那样子呢——老的方法不是很好么。最后更新的问题，Boot 项目允许你打包为 war 包而不是 jar 包，你解压一下不就可以上传了么。

还有个不痛不痒的问题，Boot 不能设置全局的 Welcome 默认页，例如（index.htm/index.jsp 等）。尽管可以单独设置某个 path 下面的，但全局不行。看来 Boot 不打算为传统页面模式提供支持。

说了那么多不好的话，但此时此刻，得说说好话。不过的确也是实事求是地说，Boot 使用起来很方便，简化了很多，但是无非仍是 Spring + Spring MVC 的高层封装，对于搞微服务的 Spring Cloud，那真是刚需。但话又说回来，你不是搞微服务，就是普通的 Web 开发，是不是 Boot 真的差异不大。

话归正题，让我们重新学习 Spring & MVC 吧！

# Spring 最小引用 #

比起我初学 Spring 那时候，Spring 5.x 对依赖简化了不少，我那时候还需要 Common-lang 和 Common Log 之类的，现在不用了。下面是使用 Spring MVC 的最小引用

<dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-webmvc</artifactId>
         <version>5.3.6</version>
    </dependency>

webmvc 自动依赖 web、context 等的包。

# 各种配置 #

为传统的模式的 Spring MVC 和 Boot 的都提供配置支持。

## 启动 Spring ##

<listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    
    
    <jsp-config>
        <jsp-property-group>
            <url-pattern>*.jsp</url-pattern>
            <page-encoding>UTF-8</page-encoding>
            <trim-directive-whitespaces>true</trim-directive-whitespaces>
        </jsp-property-group>
    </jsp-config>

在 `/WEB-INF` 下配置 `applicationContext.xml`，指定扫描的包：

<context:component-scan base-package="net.bingosoft" />
    
    
    <bean class="com.ajaxjs.spring.DiContextUtil" />

## Spring MVC 配置 ##

在指定的包之中新建一个 Spring MVC 配置类，继承 `BaseWebInitializer`。

import com.ajaxjs.spring.BaseWebInitializer;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.EnableWebMvc;
    
    @Configuration
    @EnableWebMvc
    public class WebInitializer extends BaseWebInitializer { 
    }

于是要为 MVC 设一个配置文件

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" 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-4.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    	<mvc:default-servlet-handler />
    </beans>

## 对 Request、Response 的扩展 ##

在 `web.xml` 加入一个过滤器。

<filter>
        <filter-name>InitMvcRequest</filter-name>
        <filter-class>com.ajaxjs.web.InitMvcRequest</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>InitMvcRequest</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

Boot 下使用：继承 `InitMvcRequest` 并声明为组件即可。

@Component
    @Order(1)
    InitMvcRequestFilter extends InitMvcRequest { 
    }

如果不自动扫描包，那么加入下面 bean：

<bean class="com.ajaxjs.web.InitMvcRequest" />

# Spring 工具类 #

就地取材，Spring 本身包含不少优秀的工具类，既然 Spring 为底层必定依赖的库，那么请大胆使用其工具栏吧~我知道的是，有些团队约束（或禁止）成员去写自己的工具类，例如 `StringUtil.isEmpty()` 之类的。

// 最常用的，判断是否空字符串
    StringUtils.hasText();
    // 将第一个字符改大写
    StringUtils.capitalize(Str);
    
    ObjectUtils.isEmpty([]);
    CollectionUtils.isEmpty(List/Map);
    
    Base64Utils.encodeToString();
    Base64Utils.decodeFromString();
    
    StreamUtils.copyToByteArray();
    
    UriUtils.encode(v.toString(), "utf-8");
    
    /** * 将字符进行 URL 编码，默认 UTF-8 编码 * * jdk自带的URL编码工具类 URLEncoder 在对字符串进行URI编码的时候，会把空格编码为 + 号。 * 空格的URI编码其实是：%20 搜素引擎上不少人都遇到这个问题，哀声一片。 * 解决办法大都是对编码后的字符串，进行 + 号替换为 %20。总感觉这种方式不优雅 * * @param str 正常的 Java 字符串 * * @return 已 URL 编码的字符串 */
    public static String urlEncode(String str) { 
    	try { 
    		return URLEncoder.encode(str, StandardCharsets.UTF_8.toString());
    	} catch (UnsupportedEncodingException e) { 
    		LOGGER.warning(e);
    		return null;
    	}
    }
    
    /** * 将 URL 编码的字符还原，默认 UTF-8 编码 * * @param str 已 URL 编码的字符串 * @return 正常的 Java 字符串 */
    public static String urlDecode(String str) { 
    	try { 
    		return URLDecoder.decode(str, StandardCharsets.UTF_8.toString());
    	} catch (UnsupportedEncodingException e) { 
    		LOGGER.warning(e);
    		return null;
    	}
    }

以前写的

/** * 将一个字符串分隔为字符串数组，分隔符 可以是,、/、-、\（注意转义）、|、; 作为分隔符。 常在读取配置的时候使用。 * * @param str 输入的字符串 * @return 分隔后的数组 */
    public static String[] split(String str) { 
    	return str.split(",|/|-|\\\\|\\||;");
    }
    
    @Test
    public void testSplit() { 
    	assertEquals(2, split("a,b").length);
    	assertEquals(3, split("a/b/c").length);
    	assertEquals(4, split("a\\b\\c\\d").length);
    	assertEquals(5, split("a|b|c|d|e").length);
    	assertEquals(5, split("a;b;c;d;e").length);
    }
    
    /** * 重复字符串 repeat 次并以 div 分隔 * * @param str 要重复的字符串 * @param div 字符串之间的分隔符 * @param repeat 重复次数 * @return 结果 */
    public static String repeatStr(String str, String div, int repeat) { 
    	StringBuilder s = new StringBuilder();
    	int i = 0;
    
    	while (i++ < repeat) { 
    		s.append(str);
    		if (i != repeat)
    			s.append(div);
    	}
    
    	return s.toString();
    }
    
    @Test
    public void testRepeatStr() { 
    	assertEquals(repeatStr("Hi", ",", 3), "Hi,Hi,Hi");
    }
    
    /** * 输入 a，看 a 里面是否包含另一个字符串 b，忽略大小写。 * * @param a 输入字符串 a * @param b 另一个字符串 b * @return true 表示包含 */
    public static boolean containsIgnoreCase(String a, String b) { 
    	return a.toLowerCase().contains(b.toLowerCase());
    }
    
    @Test
    public void testContainsIgnoreCase() { 
    	assertTrue(containsIgnoreCase("abc", "A"));
    }
    
    /** * 随机字符串 */
    private static final String STR = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
    
    /** * 生成指定长度的随机字符，可能包含数字 * * @param length 户要求产生字符串的长度 * @return 随机字符 */
    public static String getRandomString(int length) { 
    	Random random = new Random();
    	StringBuffer sb = new StringBuffer();
    
    	for (int i = 0; i < length; i++) { 
    		int number = random.nextInt(62);
    		sb.append(STR.charAt(number));
    	}
    
    	return sb.toString();
    }
    
    /** * 是否空字符串 * * @param str 要判断的字符串 * @return true 表示为为空字符串，否则不为空 */
    public static boolean isEmptyString(String str) { 
    	return str == null || str.isEmpty() || str.trim().isEmpty();
    }
    /** * 将第一个字母大写 * * @param str 字符串 * @return 字符串 */
    public static String firstLetterUpper(String str) { 
    	// return str.substring(0, 1).toUpperCase() + str.substring(1); // 另外一种写法
    	return Character.toString(str.charAt(0)).toUpperCase() + str.substring(1);
    }
    /** * 判断数组是否为空 * * @param arr 输入的数组 * @return true 表示为素组不是为空，是有内容的，false 表示为数组为空数组，length = 0 */
    public static boolean isNull(Object[] arr) { 
    	return arr == null || arr.length == 0;
    }
    
    assertTrue(isNull(new Object[] { }));
    assertFalse(isNull(new Object[] {  null }));
    
    /** * 判断 collection 是否为空 * * @param collection Map输入的集合 * @return true 表示为集合不是为空，是有内容的，false 表示为空集合 */
    public static boolean isNull(Collection<?> collection) { 
    	return collection == null || collection.isEmpty();
    }
    
    /** * 判断 map 是否有意义 * * @param map 输入的 * @return true 表示为 map 不是为空，是有内容的，false 表示为空 map */
    public static boolean isNull(Map<?, ?> map) { 
    	return map == null || map.isEmpty();
    }
    
    @Test
    public void testCollection() { 
    	assertTrue(isNull(new HashMap<String, String>() { 
    		private static final long serialVersionUID = 1L;
    	}));
    	assertTrue(isNull(new ArrayList<String>() { 
    		private static final long serialVersionUID = 1L;
    	}));
    
    	List<Object> list = null;
    	assertTrue(isNull(list));
    }
    
    
    // ------------BASE 64
    /** * BASE64 编码 * * @param bytes 输入的字节数组 * @return 已编码的字符串 */
    public static String base64Encode(byte[] bytes) { 
    	return Base64.getEncoder().encodeToString(bytes);
    }
    
    /** * BASE64 编码 * * @param str 待编码的字符串 * @return 已编码的字符串 */
    public static String base64Encode(String str) { 
    	return base64Encode(str.getBytes(StandardCharsets.UTF_8));
    }
    
    /** * BASE64 解码，但以 Byte 形式返回 * * @param str 待解码的字符串 * @return 已解码的 Byte */
    public static byte[] base64DecodeAsByte(String str) { 
    	try { 
    		return Base64.getDecoder().decode(str);
    	} catch (IllegalArgumentException e) { 
    		LOGGER.warning("BASE64 解码失败", e);
    		return null;
    	}
    }
    
    /** * BASE64 解码 这里需要强制捕获异常。 * 中文乱码：http://s.yanghao.org/program/viewdetail.php?i=54806 * * @param str 待解码的字符串 * @return 已解码的字符串 */
    public static String base64Decode(String str) { 
    	byte[] b = base64DecodeAsByte(str);
    	return b == null ? null : byte2String(b);
    }
    
     Stream
    
    /** * 使用内存操作流，读取二进制，也就是将流转换为内存的数据。 InputStream 转换到 byte[]. 从输入流中获取数据， 转换到 byte[] * 也就是 in 转到内存。虽然大家可能都在内存里面了但还不能直接使用，要转换 * * @param in 输入流 * @return 返回本实例供链式调用 */
    public static byte[] inputStream2Byte(InputStream in) { 
    	// 使用内存操作流，读取二进制
    	try (ByteArrayOutputStream out = new ByteArrayOutputStream();) { 
    		write(in, out, true);
    
    		return out.toByteArray();
    	} catch (IOException e) { 
    		LOGGER.warning(e);
    		return null;
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neGluMDk_size_16_color_FFFFFF_t_70]: /images/20221005/ee5f39c8e52740aea5b8b9b8eab2aa9a.png