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。

相关文章

C# WinForms存储过程操作数据库的实例讲解

C# WinForms存储过程操作数据库的实例讲解

《C#WinForms存储过程操作数据库的实例讲解》：本文主要介绍C#WinForms存储过程操作数据库的实例,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、存储过程基础二、C# 调用流程1. 数据库连接配置2. 执行存储过程（增删改）3. 查询数据三、事务处
阅读更多...
Java中StopWatch的使用示例详解

Java中StopWatch的使用示例详解

《Java中StopWatch的使用示例详解》stopWatch是org.springframework.util包下的一个工具类,使用它可直观的输出代码执行耗时,以及执行时间百分比,这篇文章主要介绍... 目录stopWatch 是org.springframework.util 包下的一个工具类，使用它
阅读更多...
Java进行文件格式校验的方案详解

Java进行文件格式校验的方案详解

《Java进行文件格式校验的方案详解》这篇文章主要为大家详细介绍了Java中进行文件格式校验的相关方案,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录一、背景异常现象原因排查用户的无心之过二、解决方案Magandroidic Number判断主流检测库对比Tika的使用区分zip
阅读更多...
Java实现时间与字符串互相转换详解

Java实现时间与字符串互相转换详解

《Java实现时间与字符串互相转换详解》这篇文章主要为大家详细介绍了Java中实现时间与字符串互相转换的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 目录一、日期格式化为字符串（一）使用预定义格式（二）自定义格式二、字符串解析为日期（一）解析ISO格式字符串（二）解析自定义
阅读更多...
Java使用Curator进行ZooKeeper操作的详细教程

Java使用Curator进行ZooKeeper操作的详细教程

《Java使用Curator进行ZooKeeper操作的详细教程》ApacheCurator是一个基于ZooKeeper的Java客户端库,它极大地简化了使用ZooKeeper的开发工作,在分布式系统... 目录1、简述2、核心功能2.1 CuratorFramework2.2 Recipes3、示例实践3
阅读更多...
Springboot处理跨域的实现方式(附Demo)

Springboot处理跨域的实现方式(附Demo)

《Springboot处理跨域的实现方式(附Demo)》：本文主要介绍Springboot处理跨域的实现方式(附Demo),具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不... 目录Springboot处理跨域的方式1. 基本知识2. @CrossOrigin3. 全局跨域设置4.
阅读更多...
springboot security使用jwt认证方式

springboot security使用jwt认证方式

《springbootsecurity使用jwt认证方式》：本文主要介绍springbootsecurity使用jwt认证方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地... 目录前言代码示例依赖定义mapper定义用户信息的实体beansecurity相关的类提供登录接口测试提供一
阅读更多...
Spring Boot 3.4.3 基于 Spring WebFlux 实现 SSE 功能(代码示例)

Spring Boot 3.4.3 基于 Spring WebFlux 实现 SSE 功能(代码示例)

《SpringBoot3.4.3基于SpringWebFlux实现SSE功能(代码示例)》SpringBoot3.4.3结合SpringWebFlux实现SSE功能,为实时数据推送提供... 目录1. SSE 简介1.1 什么是 SSE？1.2 SSE 的优点1.3 适用场景2. Spring WebFlu
阅读更多...
基于SpringBoot实现文件秒传功能

基于SpringBoot实现文件秒传功能

《基于SpringBoot实现文件秒传功能》在开发Web应用时,文件上传是一个常见需求,然而,当用户需要上传大文件或相同文件多次时,会造成带宽浪费和服务器存储冗余,此时可以使用文件秒传技术通过识别重复... 目录前言文件秒传原理代码实现1. 创建项目基础结构2. 创建上传存储代码3. 创建Result类4.
阅读更多...
Java利用JSONPath操作JSON数据的技术指南

Java利用JSONPath操作JSON数据的技术指南

《Java利用JSONPath操作JSON数据的技术指南》JSONPath是一种强大的工具,用于查询和操作JSON数据,类似于SQL的语法,它为处理复杂的JSON数据结构提供了简单且高效... 目录1、简述2、什么是 jsONPath？3、Java 示例3.1 基本查询3.2 过滤查询3.3 递归搜索3.4
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2