[关闭]
@TedZhou 2020-10-15T08:39:15.000000Z 字数 16711 阅读 535

Springboot 开发必备的工具类

java spring

StringUtils.java

  1. import java.io.UnsupportedEncodingException;
  2. import java.net.URLDecoder;
  3. import java.net.URLEncoder;
  4. import java.security.MessageDigest;
  5. import java.util.Date;
  6. import java.util.Formatter;
  7. import java.util.UUID;
  8. import org.springframework.lang.Nullable;
  9. import org.springframework.util.DigestUtils;
  11. public class StringUtils extends org.springframework.util.StringUtils {
  13.     public static boolean equals(@Nullable String str1, @Nullable String str2) {
  14.         if (str1 == null || str2 == null) {
  15.             return (str1 == null && str2 == null);
  16.         }
  17.         return str1.equals(str2);
  18.     }
  20.     public static boolean isBlank(@Nullable String string) {
  21.         if (isEmpty(string)) {
  22.             return true;
  23.         }
  24.         for (int i = 0; i < string.length(); i++) {
  25.             if (!Character.isWhitespace(string.charAt(i))) {
  26.                 return false;
  27.             }
  28.         }
  29.         return true;
  30.     }
  32.     public static boolean isNotBlank(@Nullable String string) {
  33.         return !StringUtils.isBlank(string);
  34.     }
  36.     public static boolean isBlank(@Nullable Integer id) {
  37.         return id == null || id == 0;
  38.     }
  40.     public static boolean isNotBlank(@Nullable Integer id) {
  41.         return id != null && id != 0;
  42.     }
  44.     public static String[] split(@Nullable String string, @Nullable String delimiter, int limit) {
  45.         if (isEmpty(string) || delimiter == null || limit == 1) {
  46.             return new String[]{string};
  47.         }
  48.         return string.split(delimiter, limit);
  49.     }
  51.     /* @return uuid string(32) */
  52.     public static String uuid() {
  53.         return UUID.randomUUID().toString().replace("-", "");
  54.     }
  56.     private static final String[] chars = new String[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l",
  57.             "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6",
  58.             "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
  59.             "S", "T", "U", "V", "W", "X", "Y", "Z" };
  60.     /* gen short unique id(8 chars) */
  61.     public static String unid8() {
  62.         return StringUtils.unid8(null);
  63.     }
  64.     private static String unid8(String uuid32) {
  65.         StringBuffer shortBuffer = new StringBuffer();
  66.         if (StringUtils.isBlank(uuid32)) {
  67.             uuid32 = StringUtils.uuid();
  68.         }
  69.         for (int i = 0; i < 8; i++) {
  70.             String str = uuid32.substring(i * 4, i * 4 + 4);
  71.             int x = Integer.parseInt(str, 16);
  72.             shortBuffer.append(StringUtils.chars[x % 0x3E]);
  73.         }
  74.         return shortBuffer.toString();
  75.     }
  76.     /* gen unique id(20 chars) that has timestamp */
  77.     public static String unid20() {
  78.         long ts = new Date().getTime();
  79.         return String.format("%d_%s", ts, StringUtils.unid8());
  80.     }
  82.     /* MD5, null as empty str. */
  83.     public static String MD5(String str) {
  84.         if (str == null) {
  85.             str = "";
  86.         }
  87.         return DigestUtils.md5DigestAsHex(str.getBytes());
  88.     }
  90.     /* SHA-1, null as empty str. */
  91.     public static String SHA1(String str) {
  92.         if (str == null) {
  93.             return "";
  94.         }
  95.         try {
  96.             MessageDigest crypt = MessageDigest.getInstance("SHA-1");
  97.             crypt.reset();
  98.             crypt.update(str.getBytes("UTF-8"));
  99.             return byteToHex(crypt.digest());
  100.         } catch (Exception e) {
  101.             e.printStackTrace();
  102.         }
  103.         return str;
  104.     }
  105.     private static String byteToHex(final byte[] hash) {
  106.         Formatter formatter = new Formatter();
  107.         for (byte b : hash) {
  108.             formatter.format("%02x", b);
  109.         }
  110.         String result = formatter.toString();
  111.         formatter.close();
  112.         return result;
  113.     }
  115.     public static String urlDecode(String raw) {
  116.         try {
  117.             return URLDecoder.decode(raw, "UTF-8");
  118.         } catch (UnsupportedEncodingException uee) {
  119.             throw new IllegalStateException(uee); // can't happen
  120.         }
  121.     }
  123.     public static String urlEncode(String str) {
  124.         try {
  125.             return URLEncoder.encode(str, "UTF-8");
  126.         } catch (UnsupportedEncodingException uee) {
  127.             throw new IllegalStateException(uee); // can't happen
  128.         }
  129.     }
  131.     public static String urlEncode(String str, String en) {
  132.         try {
  133.             return URLEncoder.encode(str, en);
  134.         } catch (UnsupportedEncodingException uee) {
  135.             throw new IllegalStateException(uee); // can't happen
  136.         }
  137.     }
  139.     public static String convert(String str, String from, String to) {
  140.         try {
  141.             str = new String(str.getBytes(from), to);
  142.         } catch (UnsupportedEncodingException e) {
  143.             e.printStackTrace();
  144.         }
  145.         return str;
  146.     }
  147. }

NumberUtils.java

  1. import org.springframework.lang.Nullable;
  3. public class NumberUtils extends org.springframework.util.NumberUtils {
  4.     public static <T extends Number> boolean equals(@Nullable T a, @Nullable T b) {
  5.         if (a == null || b == null) {
  6.             return (a == null && b == null);
  7.         }
  8.         return a.equals(b);
  9.     }
  11.     public static <T extends Number> T parse(String text, Class<T> targetClass, T defaultValue) {
  12.         if (text == null || text.equals("")) {
  13.             return defaultValue;
  14.         }
  15.         try {
  16.             return NumberUtils.parseNumber(text, targetClass);
  17.         }catch(Exception e){
  18.             e.printStackTrace();
  19.         }
  20.         return defaultValue;
  21.     }
  22.     public static <T extends Number> T parse(String text, Class<T> targetClass) {
  23.         return NumberUtils.parse(text, targetClass, null);
  24.     }
  25.     public static Integer parseInt(String text) {
  26.         return NumberUtils.parse(text, Integer.class);
  27.     }
  28.     public static Long parseLong(String text) {
  29.         return NumberUtils.parse(text, Long.class);
  30.     }
  31. }

DateTimeUtils.java

  1. import java.text.SimpleDateFormat;
  2. import java.time.Instant;
  3. import java.time.LocalDateTime;
  4. import java.time.ZoneOffset;
  5. import java.time.chrono.ChronoLocalDateTime;
  6. import java.time.format.DateTimeFormatter;
  7. import java.util.Date;
  8. import java.util.Locale;
  9. import org.springframework.lang.Nullable;
  11. public class DateTimeUtils {
  12.     public static final String DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
  14.     public static int compare(Date theDate, Date anotherDate) {
  15.         if (theDate == null) {
  16.             theDate = new Date();
  17.         }
  18.         if (anotherDate == null) {
  19.             anotherDate = new Date();
  20.         }
  21.         return theDate.compareTo(anotherDate);
  22.     }
  24.     public static int compare(ChronoLocalDateTime<?> theDate, ChronoLocalDateTime<?> anotherDate) {
  25.         if (theDate == null) {
  26.             theDate = LocalDateTime.now();
  27.         }
  28.         if (anotherDate == null) {
  29.             anotherDate = LocalDateTime.now();
  30.         }
  31.         return theDate.compareTo(anotherDate);
  32.     }
  34.     public static Date toDate(LocalDateTime localDateTime) {
  35.         if (localDateTime == null) return null;
  36.         return Date.from(localDateTime.toInstant(ZoneOffset.of("+8")));
  37.     }
  39.     public static LocalDateTime toLocalDateTime(Date date) {
  40.         if (date == null) return null;
  41.         return fromMilli(date.getTime());
  42.     }
  44.     public static Date parseDate(@Nullable String string) {
  45.         SimpleDateFormat format = new SimpleDateFormat(DATETIME_PATTERN, Locale.CHINA);
  46.         try {
  47.             return format.parse(string);
  48.         } catch (Exception e) {
  49.             return null;
  50.         }
  51.     }
  52.     public static LocalDateTime parseLocalDateTime(@Nullable String string) {
  53.         DateTimeFormatter format = DateTimeFormatter.ofPattern(DATETIME_PATTERN, Locale.CHINA);
  54.         try {
  55.             return LocalDateTime.parse(string, format);
  56.         } catch (Exception e) {
  57.             return null;
  58.         }
  59.     }
  61.     public static String formatDateTime(LocalDateTime dt) {
  62.         if (dt == null) return null;
  64.         DateTimeFormatter format = DateTimeFormatter.ofPattern(DATETIME_PATTERN, Locale.CHINA);
  65.         return dt.format(format);
  66.     }
  68.     public static LocalDateTime fromSecond(long second, ZoneOffset offset) {
  69.         if (offset == null) {
  70.             offset = ZoneOffset.of("+8");
  71.         }
  72.         LocalDateTime localDateTime = LocalDateTime.ofEpochSecond(second, 0, offset);
  73.         return localDateTime;
  74.     }
  75.     public static LocalDateTime fromSecond(long second) {
  76.         return DateTimeUtils.fromSecond(second, null);
  77.     }
  79.     public static LocalDateTime fromMilli(long ts, ZoneOffset offset) {
  80.         if (offset == null) {
  81.             offset = ZoneOffset.of("+8");
  82.         }
  83.         Instant instant = Instant.ofEpochMilli(ts);
  84.         LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, offset);
  85.         return localDateTime;
  86.     }
  87.     public static LocalDateTime fromMilli(long ts) {
  88.         return DateTimeUtils.fromMilli(ts, null);
  89.     }
  91.     //返回世纪秒
  92.     public static long secondsOf(ChronoLocalDateTime<?> ldt, ZoneOffset offset) {
  93.         if (ldt == null) {
  94.             return 0;
  95.         }
  96.         if (offset == null) {
  97.             offset = ZoneOffset.of("+8");
  98.         }
  99.         long second = ldt.toEpochSecond(offset);
  100.         return second;
  101.     }
  102.     public static long secondsOf(ChronoLocalDateTime<?> ldt) {
  103.         return DateTimeUtils.secondsOf(ldt, null);
  104.     }
  106.     //返回世纪毫秒
  107.     public static long micsecondsOf(ChronoLocalDateTime<?> ldt, ZoneOffset offset) {
  108.         if (ldt == null) {
  109.             return 0;
  110.         }
  111.         if (offset == null) {
  112.             offset = ZoneOffset.of("+8");
  113.         }
  114.         long mic = ldt.toInstant(offset).toEpochMilli();
  115.         return mic;
  116.     }
  117.     public static long micsecondsOf(ChronoLocalDateTime<?> ldt) {
  118.         return DateTimeUtils.micsecondsOf(ldt, null);
  119.     }
  120. }

JSON.java

  1. import java.io.IOException;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import com.fasterxml.jackson.core.JsonParseException;
  5. import com.fasterxml.jackson.core.JsonProcessingException;
  6. import com.fasterxml.jackson.core.type.TypeReference;
  7. import com.fasterxml.jackson.databind.JsonMappingException;
  8. import com.fasterxml.jackson.databind.ObjectMapper;
  9. import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
  11. public class JSON {
  12.     @SuppressWarnings("unchecked") 
  13.     public static Map<String, Object> parse(String jsonStr) {
  14.         Map<String, Object> map = new HashMap<>();
  15.         try {
  16.             map = (Map<String, Object>) JSON.parse(jsonStr, map.getClass());
  17.         } catch (Exception e) {
  18.             e.printStackTrace();
  19.             map = null;
  20.         }
  21.         return map;
  22.     }
  24.     public static <T> T parse(String jsonStr, Class<T> toClass) {
  25.         try {
  26.             ObjectMapper mapper = new ObjectMapper();
  27.             return mapper.readValue(jsonStr, toClass);
  28.         } catch (JsonParseException e) {
  29.             e.printStackTrace();
  30.         } catch (JsonMappingException e) {
  31.             e.printStackTrace();
  32.         } catch (IOException e) {
  33.             e.printStackTrace();
  34.         }
  35.         return null;
  36.     }
  38.     public static <T extends Object> T parse(String jsonStr, TypeReference<T> type) {
  39.         try {
  40.             ObjectMapper mapper = new ObjectMapper();
  41.             mapper.registerModule(new JavaTimeModule());
  42.             return mapper.readValue(jsonStr, type);
  43.         } catch (JsonParseException e) {
  44.             e.printStackTrace();
  45.         } catch (JsonMappingException e) {
  46.             e.printStackTrace();
  47.         } catch (IOException e) {
  48.             e.printStackTrace();
  49.         }
  50.         return null;
  51.     }
  53.     public static String stringify(Object obj) {
  54.         try {
  55.             ObjectMapper mapper = new ObjectMapper();
  56.             //https://howtoprogram.xyz/2017/12/30/serialize-java-8-localdate-jackson/
  57.             mapper.registerModule(new JavaTimeModule());
  58.             //mapper.disable(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS);
  59.             return mapper.writeValueAsString(obj);
  60.         } catch (JsonProcessingException e) {
  61.             e.printStackTrace();
  62.         }
  63.         return null;
  64.     }
  65. }

XmlUtils.java

  1. import java.io.IOException;
  2. import java.util.ArrayList;
  3. import java.util.Date;
  4. import java.util.HashMap;
  5. import java.util.List;
  6. import java.util.Map;
  7. import com.fasterxml.jackson.core.JsonProcessingException;
  8. import com.fasterxml.jackson.databind.ObjectWriter;
  9. import com.fasterxml.jackson.dataformat.xml.XmlMapper;
  11. public class XmlUtils {
  13.     @SuppressWarnings("unchecked") 
  14.     public static Map<String, String> parse(String xml){
  15.         Map<String, String> map = new HashMap<>();
  16.         return (Map<String, String>) XmlUtils.parse(xml, map.getClass());
  17.     }
  19.     public static <T> T parse(String xml, Class<T> toClass) {
  20.         try {
  21.             XmlMapper xmlMapper = new XmlMapper();
  22.             return xmlMapper.readValue(xml, toClass);
  23.         } catch (IOException e) {
  24.             e.printStackTrace();
  25.         }
  26.         return null;
  27.     }
  29.     public static String stringify(Object obj, String root) {
  30.         XmlMapper xmlMapper = new XmlMapper();
  31.         try {
  32.             ObjectWriter writer = xmlMapper.writer();
  33.             if (root != null && !"".equals(root)) {
  34.                 writer = writer.withRootName(root);
  35.             }
  36.             return writer.writeValueAsString(obj);
  37.         } catch (JsonProcessingException e) {
  38.             e.printStackTrace();
  39.         }
  40.         return null;
  41.     }
  42. }

BeanUtils.java

  1. import java.beans.PropertyDescriptor;
  2. import java.util.HashSet;
  3. import java.util.Set;
  4. import org.springframework.beans.BeanWrapper;
  5. import org.springframework.beans.BeanWrapperImpl;
  6. import org.springframework.util.StringUtils;
  8. public class BeanUtils extends org.springframework.beans.BeanUtils {
  9.     /* copy source properties(not null) to target */
  10.     public static void copyPropertiesNotNull(Object source, Object target) {
  11.         String[] ignoreProperties = BeanUtils.getNullProperties(source);
  12.         BeanUtils.copyProperties(source, target, ignoreProperties);
  13.     }
  15.     /* copy source properties(not empty) to target */
  16.     public static void copyPropertiesNotEmpty(Object source, Object target) {
  17.         String[] ignoreProperties = BeanUtils.getEmptyProperties(source);
  18.         BeanUtils.copyProperties(source, target, ignoreProperties);
  19.     }
  21.     /* get object's null properties */
  22.     public static String[] getNullProperties(Object obj) {
  23.         BeanWrapper bean = new BeanWrapperImpl(obj);
  24.         PropertyDescriptor[] descriptors = bean.getPropertyDescriptors();
  25.         Set<String> properties = new HashSet<>();
  26.         for (PropertyDescriptor property : descriptors) {
  27.             String propertyName = property.getName();
  28.             Object propertyValue = bean.getPropertyValue(propertyName);
  29.             if (propertyValue == null) {
  30.                 properties.add(propertyName);
  31.             }
  32.         }
  33.         return properties.toArray(new String[0]);
  34.     }
  36.     /* get object's empty properties */
  37.     public static String[] getEmptyProperties(Object obj) {
  38.         BeanWrapper bean = new BeanWrapperImpl(obj);
  39.         PropertyDescriptor[] descriptors = bean.getPropertyDescriptors();
  40.         Set<String> properties = new HashSet<>();
  41.         for (PropertyDescriptor property : descriptors) {
  42.             String propertyName = property.getName();
  43.             Object propertyValue = bean.getPropertyValue(propertyName);
  44.             if (StringUtils.isEmpty(propertyValue)) {
  45.                 properties.add(propertyName);
  46.             }
  47.         }
  48.         return properties.toArray(new String[0]);
  49.     }
  50. }

WebUtils.java

  1. import java.net.InetAddress;
  2. import java.net.UnknownHostException;
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  5. import org.springframework.web.context.request.RequestAttributes;
  6. import org.springframework.web.context.request.RequestContextHolder;
  7. import org.springframework.web.context.request.ServletRequestAttributes;
  9. public class WebUtils extends org.springframework.web.util.WebUtils {
  10.     /* 获取request对象 */
  11.     public static HttpServletRequest getRequest() {
  12.         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
  13.         if (requestAttributes == null) return null;
  15.         return ((ServletRequestAttributes) requestAttributes).getRequest();
  16.     }
  18.     /* 获取Response对象 */
  19.     public static HttpServletResponse getResponse() {
  20.         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
  21.         if (requestAttributes == null) return null;
  23.         return ((ServletRequestAttributes) requestAttributes).getResponse();
  24.     }
  26.     public static boolean isAjaxReq(HttpServletRequest req) {
  27.         //使用request.header检测是否为AJAX请求
  28.         String contentTypeHeader = req.getHeader("Content-Type");
  29.         String acceptHeader = req.getHeader("Accept");
  30.         String xRequestedWith = req.getHeader("X-Requested-With");
  31.         return ((contentTypeHeader != null && contentTypeHeader.contains("application/json"))
  32.                 || (acceptHeader != null && acceptHeader.contains("application/json"))
  33.                 || (acceptHeader != null && !acceptHeader.contains("text/html"))
  34.                 || "XMLHttpRequest".equalsIgnoreCase(xRequestedWith));
  35.     }
  37.     // 根据网卡取本机配置的IP
  38.     public static String getServerIpAddr() {
  39.         try {
  40.             InetAddress inet = InetAddress.getLocalHost();
  41.             return inet.getHostAddress();
  42.         } catch (UnknownHostException e) {
  43.             e.printStackTrace();
  44.         }
  45.         return null; 
  46.     }
  48.     public static String getWebBase() {//Web访问路径
  49.         HttpServletRequest request = getRequest();
  50.         if (request != null) {
  51.             return String.format("%s://%s:%s%s/", request.getScheme(), request.getServerName(), request.getServerPort(), request.getContextPath());
  52.         }
  53.         return "";
  54.     }
  55. }

QRCodeUtils.java

  1. import java.awt.BasicStroke;
  2. import java.awt.Color;
  3. import java.awt.Graphics2D;
  4. import java.awt.geom.RoundRectangle2D;
  5. import java.awt.image.BufferedImage;
  6. import java.io.ByteArrayOutputStream;
  7. import java.io.File;
  8. import java.io.IOException;
  9. import java.util.Hashtable;
  10. import javax.imageio.ImageIO;
  11. import com.google.zxing.BarcodeFormat;
  12. import com.google.zxing.EncodeHintType;
  13. import com.google.zxing.WriterException;
  14. import com.google.zxing.client.j2se.MatrixToImageWriter;
  15. import com.google.zxing.common.BitMatrix;
  16. import com.google.zxing.qrcode.QRCodeWriter;
  17. import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
  19. public class QRCodeUtils {
  20.     private static final String FORMAT_PNG = "JPG";//"PNG";
  21.     // 二维码尺寸
  22.     private static final int QRCODE_SIZE = 300;
  24.     private static final int BLACK = 0xFF000000;//用于设置图案的颜色  
  25.     private static final int WHITE = 0xFFFFFFFF; //用于背景色  
  27.     public static byte[] genQRCodeImageBytes(String str) {
  28.         return QRCodeUtils.genQRCodeImageBytes(str, null, QRCODE_SIZE, QRCODE_SIZE);
  29.     }
  31.     public static byte[] genQRCodeImageBytes(String str, String logoPath) {
  32.         return QRCodeUtils.genQRCodeImageBytes(str, logoPath, QRCODE_SIZE, QRCODE_SIZE);
  33.     }
  35.     public static byte[] genQRCodeImageBytes(String str, String logoPath, int width, int height) {
  36.         byte[] qrcode = null;
  37.         try {
  38.             QRCodeWriter qrCodeWriter = new QRCodeWriter();
  39.             Hashtable<EncodeHintType, Object> hints = new Hashtable<>();
  40.             hints.put(EncodeHintType.CHARACTER_SET, "utf-8");
  41.             hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.M);
  42.             BitMatrix bitMatrix = qrCodeWriter.encode(str, BarcodeFormat.QR_CODE, width, height, hints);
  44.             ByteArrayOutputStream pngOutputStream = new ByteArrayOutputStream();
  45.             if (StringUtils.isBlank(logoPath)) {
  46.                 MatrixToImageWriter.writeToStream(bitMatrix, FORMAT_PNG, pngOutputStream);
  47.             } else {
  48.                 BufferedImage image = QRCodeUtils.toBufferedImage(bitMatrix);
  49.                 QRCodeUtils.addLogo(image, logoPath);
  50.                 ImageIO.write(image, FORMAT_PNG, pngOutputStream);
  51.             }
  52.             qrcode = pngOutputStream.toByteArray();
  53.         } catch (WriterException e) {
  54.             System.out.println("Could not generate QR Code, WriterException :: " + e.getMessage());
  55.             e.printStackTrace();
  56.         } catch (IOException e) {
  57.             System.out.println("Could not generate QR Code, IOException :: " + e.getMessage());
  58.             e.printStackTrace();
  59.         }
  60.         return qrcode;
  61.     }
  63.     private static BufferedImage toBufferedImage(BitMatrix matrix) {  
  64.         int width = matrix.getWidth();  
  65.         int height = matrix.getHeight();  
  66.         BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);  
  67.         for (int x = 0; x < width; x++) {  
  68.             for (int y = 0; y < height; y++) {  
  69.                 image.setRGB(x, y,  (matrix.get(x, y) ? BLACK : WHITE));  
  70.                 //image.setRGB(x, y,  (matrix.get(x, y) ? Color.YELLOW.getRGB() : Color.CYAN.getRGB()));  
  71.             }  
  72.         }  
  73.         return image;  
  74.     }
  76.     // 二维码加 logo
  77.     private static BufferedImage addLogo(BufferedImage matrixImage, String logoPath) {
  78.         int matrixWidth = matrixImage.getWidth();
  79.         int matrixHeigh = matrixImage.getHeight();
  81.         //读取二维码图片，并构建绘图对象
  82.         Graphics2D g2 = matrixImage.createGraphics();
  83.         BufferedImage logoImage;
  84.         try {
  85.             logoImage = ImageIO.read(new File(logoPath));//读取Logo图片
  86.             // 开始绘制图片
  87.             g2.drawImage(logoImage, matrixWidth / 5 * 2, matrixHeigh / 5 * 2, matrixWidth / 5, matrixHeigh / 5, null);// 绘制
  88.             BasicStroke stroke = new BasicStroke(5, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
  89.             g2.setStroke(stroke);// 设置笔画对象
  90.             RoundRectangle2D.Float round = new RoundRectangle2D.Float(matrixWidth / 5 * 2, matrixHeigh / 5 * 2, matrixWidth / 5, matrixHeigh / 5, 20, 20);//指定弧度的圆角矩形
  91.             g2.setColor(Color.white);
  92.             g2.draw(round);// 绘制圆弧矩形
  94.             // 设置logo 有一道灰色边框
  95.             BasicStroke stroke2 = new BasicStroke(1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND);
  96.             g2.setStroke(stroke2);// 设置笔画对象
  97.             RoundRectangle2D.Float round2 = new RoundRectangle2D.Float(matrixWidth / 5 * 2 + 2, matrixHeigh / 5 * 2 + 2, matrixWidth / 5 - 4, matrixHeigh / 5 - 4, 20, 20);
  98.             g2.setColor(new Color(128, 128, 128));
  99.             g2.draw(round2);// 绘制圆弧矩形
  101.         } catch (IOException e) {
  102.             e.printStackTrace();
  103.         }
  105.         g2.dispose();
  106.         matrixImage.flush();
  107.         return matrixImage;
  108.     }
  109. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注