Spring源代码分析（13)---BLOB和CLOB操作(不是大就了不起)

2024-04-27 11:18
文章标签 java 分析 不是 操作 spring 源代码 13 了不起 blob clob

本文主要是介绍Spring源代码分析（13)---BLOB和CLOB操作(不是大就了不起)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

我们在项目中，经常碰到图片存储，文章存储的问题，在这类问题的解决方案中，我们经常是采用把这类大数据对象保存在文件系统中，但是这又带来了一系列问题，图片存储在文件系统中，很不安全，很多情况都是能够被人所copy，破坏等等，那么，我们可以选择将其保存在数据库中，主流数据库都已经基本实现了 Blob,Clob等数据字段类型，但是，因为JDBC没有一个Blob，Clob的具体类型实现，每种数据库对这种类型存储机制都不相同，因此，大大的降低了我们的系统在数据库的迁移性，那么这一些Spring来帮助我们解决这个该死的强耦合，大，并不是就了不起！


首先:

applicationContext.xml:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
  6.     <bean  id="dataSource"
  7.         class="org.apache.commons.dbcp.BasicDataSource">
  8.         <property name="driverClassName"
  9.             value="com.mysql.jdbc.Driver">
  10.         </property>
  11.         <property name="url" value="jdbc:mysql://127.0.0.1:3306/test"></property>
  12.         <property name="username" value="root"></property>
  13.     </bean>
  16.     <!-- 用户获取Oracle源连接 -->
  17.     <bean id="nativeJdbcExtrector" name="nativeJdbcExtrector"
  18.         class="org.springframework.jdbc.support.nativejdbc.C3P0NativeJdbcExtractor"
  19.         abstract="false" lazy-init="default" autowire="default"
  20.         dependency-check="default">
  21.     </bean>
  22.     <!-- Oracle大对象处理器 -->
  23.     <bean id="oracleLobHandler" name="oracleLobHandler"
  24.         class="org.springframework.jdbc.support.lob.OracleLobHandler"
  25.         abstract="false" lazy-init="default" autowire="default"
  26.         dependency-check="default">
  27.         <property name="nativeJdbcExtractor">
  28.             <ref bean="nativeJdbcExtractor"></ref>
  29.         </property>
  30.     </bean>
  31.     <bean id="defaultLobhandler" name="defaultLobhandler"
  32.         class="org.springframework.jdbc.support.lob.DefaultLobHandler"
  33.         abstract="false" lazy-init="default" autowire="default"
  34.         dependency-check="default">
  35.     </bean>
  36.     <bean id="lobDao" name="lobDao" class="LobDaoSupport"
  37.         abstract="false" lazy-init="default" autowire="default"
  38.         dependency-check="default">
  39.         <property name="lobHandler">
  40.             <ref bean="oracleLobHandler"></ref>
  41.         </property>
  42.     </bean>
  43. </beans>

代码：
  1. package org.syna.demo;
  3. import org.springframework.jdbc.support.lob.LobHandler;
  5. public interface Lober {
  6.     /**
  7.      * 设置大对象处理器
  8.      * @param handler
  9.      */
  10.     public void setLobHandler(LobHandler handler);
  11.     
  12. }
  1. package org.syna.demo;
  3. import java.util.List;
  5. public interface ImageReader {
  6.     
  7.     /**
  8.      * 获取存储在数据库中的图片的描述，其类型为Clob
  9.      * @param imageID
  10.      * @return
  11.      */
  12.     public List getImageDescription();
  13.     
  14.     /**
  15.      * 获取存储在数据库中的图片的输入流，其类型类Blob
  16.      * @param imageID
  17.      * @return
  18.      */
  19.     public List getImage();
  21. }

  1. package org.syna.demo;
  3. import java.sql.ResultSet;
  4. import java.sql.SQLException;
  5. import java.util.List;
  7. import org.springframework.jdbc.core.RowMapper;
  8. import org.springframework.jdbc.core.support.JdbcDaoSupport;
  9. import org.springframework.jdbc.support.lob.LobHandler;
  11. public class LobDaoSupport extends JdbcDaoSupport implements ImageReader, Lober {
  13.     private LobHandler lobHandler;
  15.     public void setLobHandler(LobHandler handler) {
  16.         this.lobHandler = handler;
  17.     }
  19.     public List getImage() {
  20.         return this.getJdbcTemplate().query("select Iamge from Images ",
  21.                 new RowMapper() {
  23.                     public Object mapRow(ResultSet rs, int rowNum)
  24.                             throws SQLException {
  25.                         return lobHandler.getBlobAsBytes(rs, 1);
  26.                     }
  27.                 });
  28.     }
  30.     public List getImageDescription() {
  31.         return this.getJdbcTemplate().query("select descripton from images",
  32.                 new RowMapper() {
  34.                     public Object mapRow(ResultSet rs, int rowNum)
  35.                             throws SQLException {
  36.                         String description = lobHandler.getClobAsString(rs, 1);
  37.                         return description;
  38.                     }
  40.                 });
  41.     }
  43.     private LobHandler handler;
  45. }
我们首先来看一下LobHandler都能做写什么？

  1. public interface LobHandler {
  2.        //将Blob对象转换为byte数组；
  3.     byte[] getBlobAsBytes(ResultSet rs, String columnName) throws SQLException;

  5.     
  6.     byte[] getBlobAsBytes(ResultSet rs, int columnIndex) throws SQLException;

  8.     //将Blob对象转换为流
  9.     InputStream getBlobAsBinaryStream(ResultSet rs, String columnName) throws SQLException;

  11.     
  12.     InputStream getBlobAsBinaryStream(ResultSet rs, int columnIndex) throws SQLException;

  14.     //将Clob转换为字符串
  15.     String getClobAsString(ResultSet rs, String columnName) throws SQLException;

  17.     
  18.     String getClobAsString(ResultSet rs, int columnIndex) throws SQLException;
  19.         //将Clob转为流
  20.     InputStream getClobAsAsciiStream(ResultSet rs, String columnName) throws SQLException;

  22.     
  23.     InputStream getClobAsAsciiStream(ResultSet rs, int columnIndex) throws SQLException;

  25.     Reader getClobAsCharacterStream(ResultSet rs, String columnName) throws SQLException;

  27.     /
  28.     Reader getClobAsCharacterStream(ResultSet rs, int columnIndex) throws SQLException;

  30.     //得到一个Lob对象的工厂，他能够生产出Blob和Clob,
  31.         //等会会进行详细分析；
  32.     LobCreator getLobCreator();

  34. }

我们来看一下OracleLobHandler的具体实现：
 
  1. public class OracleLobHandler extends AbstractLobHandler {
  2.         //Oracle大对象类的具体实现，经常我们就是在这里与数据库造成耦 //合，因为Mysql也有自己的实现；
  3.     private static final String BLOB_CLASS_NAME = "oracle.sql.BLOB";
  5.     private static final String CLOB_CLASS_NAME = "oracle.sql.CLOB";
  7.     private static final String DURATION_SESSION_FIELD_NAME = "DURATION_SESSION";
  9.     private static final String MODE_READWRITE_FIELD_NAME = "MODE_READWRITE";
  12.     protected final Log logger = LogFactory.getLog(getClass());
  13.         //一个JDBC本地抽取器；对代理连接等等作出抽取；
  14.     private NativeJdbcExtractor nativeJdbcExtractor;
  16.     private Boolean cache = Boolean.TRUE;
  18.     private Class blobClass;
  20.     private Class clobClass;
  22.     private final Map durationSessionConstants = new HashMap(2);
  24.     private final Map modeReadWriteConstants = new HashMap(2);
  27.     //在这里我们可以设置成为Oracle的抽取器；
  28.     public void setNativeJdbcExtractor(NativeJdbcExtractor nativeJdbcExtractor) {
  29.         this.nativeJdbcExtractor = nativeJdbcExtractor;
  30.     }
  32.     
  33.     public void setCache(boolean cache) {
  34.         this.cache = new Boolean(cache);
  35.     }
  38.     //初始化驱动类的大对象；
  39.     protected synchronized void initOracleDriverClasses(Connection con) {
  40.         if (this.blobClass == null) {
  41.             try {
  42.                 // Initialize oracle.sql.BLOB class
  43.                 this.blobClass = con.getClass().getClassLoader().loadClass(BLOB_CLASS_NAME);
  44.                 this.durationSessionConstants.put(
  45.                         this.blobClass, new Integer(this.blobClass.getField(DURATION_SESSION_FIELD_NAME).getInt(null)));
  46.                 this.modeReadWriteConstants.put(
  47.                         this.blobClass, new Integer(this.blobClass.getField(MODE_READWRITE_FIELD_NAME).getInt(null)));
  49.                 // Initialize oracle.sql.CLOB class
  50.                 this.clobClass = con.getClass().getClassLoader().loadClass(CLOB_CLASS_NAME);
  51.                 this.durationSessionConstants.put(
  52.                         this.clobClass, new Integer(this.clobClass.getField(DURATION_SESSION_FIELD_NAME).getInt(null)));
  53.                 this.modeReadWriteConstants.put(
  54.                         this.clobClass, new Integer(this.clobClass.getField(MODE_READWRITE_FIELD_NAME).getInt(null)));
  55.             }
  56.             catch (Exception ex) {
  57.                 throw new InvalidDataAccessApiUsageException(
  58.                         "Couldn't initialize OracleLobHandler because Oracle driver classes are not available. " +
  59.                         "Note that OracleLobHandler requires Oracle JDBC driver 9i or higher!", ex);
  60.             }
  61.         }
  62.     }
  64.         //委托给Blob接口；  
  65.     public byte[] getBlobAsBytes(ResultSet rs, int columnIndex) throws SQLException {
  66.         logger.debug("Returning Oracle BLOB as bytes");
  67.         Blob blob = rs.getBlob(columnIndex);
  68.         return (blob != null ? blob.getBytes(1, (int) blob.length()) : null);
  69.     }
  71.     public InputStream getBlobAsBinaryStream(ResultSet rs, int columnIndex) throws SQLException {
  72.         logger.debug("Returning Oracle BLOB as binary stream");
  73.         Blob blob = rs.getBlob(columnIndex);
  74.         return (blob != null ? blob.getBinaryStream() : null);
  75.     }
  77.     public String getClobAsString(ResultSet rs, int columnIndex) throws SQLException {
  78.         logger.debug("Returning Oracle CLOB as string");
  79.         Clob clob = rs.getClob(columnIndex);
  80.         return (clob != null ? clob.getSubString(1, (int) clob.length()) : null);
  81.     }
  83.     public InputStream getClobAsAsciiStream(ResultSet rs, int columnIndex) throws SQLException {
  84.         logger.debug("Returning Oracle CLOB as ASCII stream");
  85.         Clob clob = rs.getClob(columnIndex);
  86.         return (clob != null ? clob.getAsciiStream() : null);
  87.     }
  89.     public Reader getClobAsCharacterStream(ResultSet rs, int columnIndex) throws SQLException {
  90.         logger.debug("Returning Oracle CLOB as character stream");
  91.         Clob clob = rs.getClob(columnIndex);
  92.         return (clob != null ? clob.getCharacterStream() : null);
  93.     }
  95.     public LobCreator getLobCreator() {
  96.         return new OracleLobCreator();
  97.     }
  99.        //内部类，具体的Lob工厂，能够生成Oracle的Lob对象；
  100.     protected class OracleLobCreator implements LobCreator {
  102.         private final List createdLobs = new LinkedList();
  104.         public void setBlobAsBytes(PreparedStatement ps, int paramIndex, final byte[] content)
  105.                 throws SQLException {
  107.             if (content != null) {
  108.                 Blob blob = (Blob) createLob(ps, false, new LobCallback() {
  109.                     public void populateLob(Object lob) throws Exception {
  110.                         Method methodToInvoke = lob.getClass().getMethod("getBinaryOutputStream", new Class[0]);
  111.                         OutputStream out = (OutputStream) methodToInvoke.invoke(lob, (Object[]) null);
  112.                         FileCopyUtils.copy(content, out);
  113.                     }
  114.                 });
  115.                 ps.setBlob(paramIndex, blob);
  116.                 if (logger.isDebugEnabled()) {
  117.                     logger.debug("Set bytes for Oracle BLOB with length " + blob.length());
  118.                 }
  119.             }
  120.             else {
  121.                 ps.setBlob(paramIndex, null);
  122.                 logger.debug("Set Oracle BLOB to null");
  123.             }
  124.         }
  126.         public void setBlobAsBinaryStream(
  127.                 PreparedStatement ps, int paramIndex, final InputStream binaryStream, int contentLength)
  128.                 throws SQLException {
  130.             if (binaryStream != null) {
  131.                 Blob blob = (Blob) createLob(ps, false, new LobCallback() {
  132.                     public void populateLob(Object lob) throws Exception {
  133.                         ///生成一个空的Blob对象以后，用getBinaryOutputStream得到一个输出流，从一个二进制输入流中将流输出到Blob对象中；前后调用的Open和Close方法就是关闭流的操作；
  134.                         Method methodToInvoke = lob.getClass().getMethod("getBinaryOutputStream", (Class[]) null);
  135.                         OutputStream out = (OutputStream) methodToInvoke.invoke(lob, (Object[]) null);
  136.                         FileCopyUtils.copy(binaryStream, out);
  137.                     }
  138.                 });
  139.                 ps.setBlob(paramIndex, blob);
  140.                 if (logger.isDebugEnabled()) {
  141.                     logger.debug("Set binary stream for Oracle BLOB with length " + blob.length());
  142.                 }
  143.             }
  144.             else {
  145.                 ps.setBlob(paramIndex, null);
  146.                 logger.debug("Set Oracle BLOB to null");
  147.             }
  148.         }
  150.         public void setClobAsString(PreparedStatement ps, int paramIndex, final String content)
  151.             throws SQLException {
  153.             if (content != null) {
  154.                 Clob clob = (Clob) createLob(ps, true, new LobCallback() {
  155.                     public void populateLob(Object lob) throws Exception {
  156.                         Method methodToInvoke = lob.getClass().getMethod("getCharacterOutputStream", (Class[]) null);
  157.                         Writer writer = (Writer) methodToInvoke.invoke(lob, (Object[]) null);
  158.                         FileCopyUtils.copy(content, writer);
  159.                     }
  160.                 });
  161.                 ps.setClob(paramIndex, clob);
  162.                 if (logger.isDebugEnabled()) {
  163.                     logger.debug("Set string for Oracle CLOB with length " + clob.length());
  164.                 }
  165.             }
  166.             else {
  167.                 ps.setClob(paramIndex, null);
  168.                 logger.debug("Set Oracle CLOB to null");
  169.             }
  170.         }
  172.         public void setClobAsAsciiStream(
  173.                 PreparedStatement ps, int paramIndex, final InputStream asciiStream, int contentLength)
  174.             throws SQLException {
  176.             if (asciiStream != null) {
  177.                 Clob clob = (Clob) createLob(ps, true, new LobCallback() {
  178.                     public void populateLob(Object lob) throws Exception {
  179.                         Method methodToInvoke = lob.getClass().getMethod("getAsciiOutputStream", (Class[]) null);
  180.                         OutputStream out = (OutputStream) methodToInvoke.invoke(lob, (Object[]) null);
  181.                         FileCopyUtils.copy(asciiStream, out);
  182.                     }
  183.                 });
  184.                 ps.setClob(paramIndex, clob);
  185.                 if (logger.isDebugEnabled()) {
  186.                     logger.debug("Set ASCII stream for Oracle CLOB with length " + clob.length());
  187.                 }
  188.             }
  189.             else {
  190.                 ps.setClob(paramIndex, null);
  191.                 logger.debug("Set Oracle CLOB to null");
  192.             }
  193.         }
  195.         public void setClobAsCharacterStream(
  196.                 PreparedStatement ps, int paramIndex, final Reader characterStream, int contentLength)
  197.             throws SQLException {
  199.             if (characterStream != null) {
  200.                 Clob clob = (Clob) createLob(ps, true, new LobCallback() {
  201.                     public void populateLob(Object lob) throws Exception {
  202.                         Method methodToInvoke = lob.getClass().getMethod("getCharacterOutputStream", (Class[]) null);
  203.                         Writer writer = (Writer) methodToInvoke.invoke(lob, (Object[]) null);
  204.                         FileCopyUtils.copy(characterStream, writer);
  205.                     }
  206.                 });
  207.                 ps.setClob(paramIndex, clob);
  208.                 if (logger.isDebugEnabled()) {
  209.                     logger.debug("Set character stream for Oracle CLOB with length " + clob.length());
  210.                 }
  211.             }
  212.             else {
  213.                 ps.setClob(paramIndex, null);
  214.                 logger.debug("Set Oracle CLOB to null");
  215.             }
  216.         }
  218.         /**
  219.          * Create a LOB instance for the given PreparedStatement,
  220.          * populating it via the given callback.
  221.          */
  222.         protected Object createLob(PreparedStatement ps, boolean clob, LobCallback callback)
  223.                 throws SQLException {
  225.             Connection con = null;
  226.             try {
  227.                 con = getOracleConnection(ps);
  228.                 initOracleDriverClasses(con);
  229.                 Object lob = prepareLob(con, clob ? clobClass : blobClass);
  230.                 callback.populateLob(lob);
  231.                 ///lob.close();
  232.                 lob.getClass().getMethod("close", (Class[]) null).invoke(lob, (Object[]) null);
  233.                 //利用这个工厂所生产出来的连接会在工厂关闭时进行统一的freeTemporary方法调用；
  234.              this.createdLobs.add(lob);
  235.                 if (logger.isDebugEnabled()) {
  236.                     logger.debug("Created new Oracle " + (clob ? "CLOB" : "BLOB"));
  237.                 }
  238.                 return lob;
  239.             }
  240.             catch (SQLException ex) {
  241.                 throw ex;
  242.             }
  243.             catch (InvocationTargetException ex) {
  244.                 if (ex.getTargetException() instanceof SQLException) {
  245.                     throw (SQLException) ex.getTargetException();
  246.                 }
  247.                 else if (con != null && ex.getTargetException() instanceof ClassCastException) {
  248.                     throw new InvalidDataAccessApiUsageException(
  249.                             "OracleLobCreator needs to work on [oracle.jdbc.OracleConnection], not on [" +
  250.                             con.getClass().getName() + "]: specify a corresponding NativeJdbcExtractor",
  251.                             ex.getTargetException());
  252.                 }
  253.                 else {
  254.                     throw new DataAccessResourceFailureException("Could not create Oracle LOB",
  255.                             ex.getTargetException());
  256.                 }
  257.             }
  258.             catch (Exception ex) {
  259.                 throw new DataAccessResourceFailureException("Could not create Oracle LOB", ex);
  260.             }
  261.         }
  263.         /**
  264.          * 抽取连接.
  265.          */
  266.  
  267.         protected Connection getOracleConnection(PreparedStatement ps)
  268.                 throws SQLException, ClassNotFoundException {
  270.             return (nativeJdbcExtractor != null) ?
  271.                     nativeJdbcExtractor.getNativeConnectionFromStatement(ps) : ps.getConnection();
  272.         }
  274.         /**
  275.          * Create and open an oracle.sql.BLOB/CLOB instance via reflection.
  276.          */
  277.         protected Object prepareLob(Connection con, Class lobClass) throws Exception {
  278.             /*
  279.             BLOB blob = BLOB.createTemporary(con, false, BLOB.DURATION_SESSION);
  280.             blob.open(BLOB.MODE_READWRITE);
  281.             return blob;
  282.             */

  284.             Method createTemporary = lobClass.getMethod(
  285.                     "createTemporary", new Class[] {Connection.class, boolean.class, int.class});
  286.             Object lob = createTemporary.invoke(
  287.                     null, new Object[] {con, cache, durationSessionConstants.get(lobClass)});
  288.             Method open = lobClass.getMethod("open", new Class[] {int.class});
  289.             open.invoke(lob, new Object[] {modeReadWriteConstants.get(lobClass)});
  290.             return lob;
  291.         }
  293.         /**
  294.          * Free all temporary BLOBs and CLOBs created by this creator.
  295.          */
  296.         public void close() {
  297.             try {
  298.                 for (Iterator it = this.createdLobs.iterator(); it.hasNext();) {
  299.                     /*
  300.                     BLOB blob = (BLOB) it.next();
  301.                     blob.freeTemporary();
  302.                     */
  303.                     Object lob = it.next();
  304.                     Method freeTemporary = lob.getClass().getMethod("freeTemporary", new Class[0]);
  305.                     freeTemporary.invoke(lob, new Object[0]);
  306.                     it.remove();
  307.                 }
  308.             }
  309.             catch (InvocationTargetException ex) {
  310.                 logger.error("Could not free Oracle LOB", ex.getTargetException());
  311.             }
  312.             catch (Exception ex) {
  313.                 throw new DataAccessResourceFailureException("Could not free Oracle LOB", ex);
  314.             }
  315.         }
  316.     }
  319.     /**
  320.      * Internal callback interface for use with createLob.
  321.      */
  322.     protected static interface LobCallback {
  324.         /**
  325.          * Populate the given BLOB or CLOB instance with content.
  326.          * @throws Exception any exception including InvocationTargetException
  327.          */
  328.         void populateLob(Object lob) throws Exception;
  329.     }
  331. }
因为大对象有Blob和Clob两种，所以这里大大对象的生成都是通过反射来做的;基本实现方式都是这种；

  1.             BLOB blob = BLOB.createTemporary(con, false, BLOB.DURATION_SESSION);
  2.             blob.open(BLOB.MODE_READWRITE);
  3.             return blob；
Clob同理；

至于如何插入Blob,Clob对象，那么就跟我们开始看见的一样，必须用到LobCreater工厂生产出大对象；

  1. private void execute saveImage(String description,byte[] content,int id){
  2.         this.getJdbcTemplate().execute("insert into IMAGES(id,description,content)", new AbstractLobCreatingPreparedStatementCallback(this.lobHandler){
  4.             @Override
  5.             protected void setValues(PreparedStatement ps, LobCreator lobCreator)
  6.                     throws SQLException, DataAccessException {
  7.                ps.setInt(1, id);
  8.                lobCreator.setClobAsString(ps, 2, description);
  9.                lobCreator.setBlobAsBytes(ps, 3, content);
  10.             }
  11.         });
  12.     }
这个PreparedStatementCallback子类如下：
  1. public abstract class AbstractLobCreatingPreparedStatementCallback implements PreparedStatementCallback {
  3.     private final LobHandler lobHandler;
  5.     public AbstractLobCreatingPreparedStatementCallback(LobHandler lobHandler) {
  6.         this.lobHandler = lobHandler;
  7.     }
  9.     public final Object doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {
  10.         LobCreator lobCreator = this.lobHandler.getLobCreator();
  11.         try {
  12.             setValues(ps, lobCreator);
  13.             return new Integer(ps.executeUpdate());
  14.         }
  15.         finally {
  16.             lobCreator.close();
  17.         }
  18.     }
  20.     
  21.     protected abstract void setValues(PreparedStatement ps, LobCreator lobCreator)
  22.             throws SQLException, DataAccessException;
  24. }
又是一次模板模式的应用；
这时，我们切换数据库的时候，不用再修改源代码，把Oracle.sql.BLOB修改成为om.mysql.jdbc.Blob了，我们只要修改注入到dao中的LobHandler就可以啦；


这篇关于Spring源代码分析（13)---BLOB和CLOB操作(不是大就了不起)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/940358。

相关文章

Java学习手册之Filter和Listener使用方法

Java学习手册之Filter和Listener使用方法

《Java学习手册之Filter和Listener使用方法》：本文主要介绍Java学习手册之Filter和Listener使用方法的相关资料,Filter是一种拦截器,可以在请求到达Servl... 目录一、Filter（过滤器）1. Filter 的工作原理2. Filter 的配置与使用二、Listen
阅读更多...
Spring Boot中JSON数值溢出问题从报错到优雅解决办法

Spring Boot中JSON数值溢出问题从报错到优雅解决办法

《SpringBoot中JSON数值溢出问题从报错到优雅解决办法》：本文主要介绍SpringBoot中JSON数值溢出问题从报错到优雅的解决办法,通过修改字段类型为Long、添加全局异常处理和... 目录一、问题背景：为什么我的接口突然报错了？二、为什么会发生这个错误？1. Java 数据类型的“容量”限制
阅读更多...
Java对象转换的实现方式汇总

Java对象转换的实现方式汇总

《Java对象转换的实现方式汇总》：本文主要介绍Java对象转换的多种实现方式,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录Java对象转换的多种实现方式1. 手动映射（Manual Mapping）2. Builder模式3. 工具类辅助映
阅读更多...
SpringBoot请求参数接收控制指南分享

SpringBoot请求参数接收控制指南分享

《SpringBoot请求参数接收控制指南分享》：本文主要介绍SpringBoot请求参数接收控制指南,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Spring Boot 请求参数接收控制指南1. 概述2. 有注解时参数接收方式对比3. 无注解时接收参数默认位置
阅读更多...
SpringBoot基于配置实现短信服务策略的动态切换

SpringBoot基于配置实现短信服务策略的动态切换

《SpringBoot基于配置实现短信服务策略的动态切换》这篇文章主要为大家详细介绍了SpringBoot在接入多个短信服务商（如阿里云、腾讯云、华为云）后,如何根据配置或环境切换使用不同的服务商,需... 目录目标功能示例配置（application.yml）配置类绑定短信发送策略接口示例：阿里云 & 腾
阅读更多...
Python ZIP文件操作技巧详解

Python ZIP文件操作技巧详解

《PythonZIP文件操作技巧详解》在数据处理和系统开发中,ZIP文件操作是开发者必须掌握的核心技能,Python标准库提供的zipfile模块以简洁的API和跨平台特性,成为处理ZIP文件的首选... 目录一、ZIP文件操作基础三板斧1.1 创建压缩包1.2 解压操作1.3 文件遍历与信息获取二、进阶技
阅读更多...
SpringBoot项目中报错The field screenShot exceeds its maximum permitted size of 1048576 bytes.的问题及解决

SpringBoot项目中报错The field screenShot exceeds its maximum permitted size of 1048576 bytes.的问题及解决

《SpringBoot项目中报错ThefieldscreenShotexceedsitsmaximumpermittedsizeof1048576bytes.的问题及解决》这篇文章... 目录项目场景问题描述原因分析解决方案总结项目场景javascript提示：项目相关背景：项目场景：基于Spring
阅读更多...
Spring Boot 整合 SSE的高级实践(Server-Sent Events)

Spring Boot 整合 SSE的高级实践(Server-Sent Events)

《SpringBoot整合SSE的高级实践(Server-SentEvents)》SSE（Server-SentEvents）是一种基于HTTP协议的单向通信机制,允许服务器向浏览器持续发送实... 目录1、简述2、Spring Boot 中的SSE实现2.1 添加依赖2.2 实现后端接口2.3 配置超时时
阅读更多...
Spring Boot读取配置文件的五种方式小结

Spring Boot读取配置文件的五种方式小结

《SpringBoot读取配置文件的五种方式小结》SpringBoot提供了灵活多样的方式来读取配置文件,这篇文章为大家介绍了5种常见的读取方式,文中的示例代码简洁易懂,大家可以根据自己的需要进... 目录1. 配置文件位置与加载顺序2. 读取配置文件的方式汇总方式一：使用 @Value 注解读取配置方式二
阅读更多...
一文详解Java异常处理你都了解哪些知识

一文详解Java异常处理你都了解哪些知识

《一文详解Java异常处理你都了解哪些知识》：本文主要介绍Java异常处理的相关资料,包括异常的分类、捕获和处理异常的语法、常见的异常类型以及自定义异常的实现,文中通过代码介绍的非常详细,需要的朋... 目录前言一、什么是异常二、异常的分类2.1 受检异常2.2 非受检异常三、异常处理的语法3.1 try-
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2