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。

相关文章

在Ubuntu上部署SpringBoot应用的操作步骤

在Ubuntu上部署SpringBoot应用的操作步骤

《在Ubuntu上部署SpringBoot应用的操作步骤》随着云计算和容器化技术的普及,Linux服务器已成为部署Web应用程序的主流平台之一,Java作为一种跨平台的编程语言,具有广泛的应用场景,本... 目录一、部署准备二、安装 Java 环境1. 安装 JDK2. 验证 Java 安装三、安装 mys
阅读更多...
Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单

《Springboot的ThreadPoolTaskScheduler线程池轻松搞定15分钟不操作自动取消订单》：本文主要介绍Springboot的ThreadPoolTaskScheduler线... 目录ThreadPoolTaskScheduler线程池实现15分钟不操作自动取消订单概要1，创建订单后
阅读更多...
JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

JAVA中整型数组、字符串数组、整型数和字符串 的创建与转换的方法

《JAVA中整型数组、字符串数组、整型数和字符串的创建与转换的方法》本文介绍了Java中字符串、字符数组和整型数组的创建方法,以及它们之间的转换方法,还详细讲解了字符串中的一些常用方法,如index... 目录一、字符串、字符数组和整型数组的创建1、字符串的创建方法1.1 通过引用字符数组来创建字符串1.2
阅读更多...
SpringCloud集成AlloyDB的示例代码

SpringCloud集成AlloyDB的示例代码

《SpringCloud集成AlloyDB的示例代码》AlloyDB是GoogleCloud提供的一种高度可扩展、强性能的关系型数据库服务,它兼容PostgreSQL,并提供了更快的查询性能... 目录1.AlloyDBjavascript是什么？AlloyDB 的工作原理2.搭建测试环境3.代码工程1.
阅读更多...
Java调用Python代码的几种方法小结

Java调用Python代码的几种方法小结

《Java调用Python代码的几种方法小结》Python语言有丰富的系统管理、数据处理、统计类软件包,因此从java应用中调用Python代码的需求很常见、实用,本文介绍几种方法从java调用Pyt... 目录引言Java core使用ProcessBuilder使用Java脚本引擎总结引言python
阅读更多...
SpringBoot操作spark处理hdfs文件的操作方法

SpringBoot操作spark处理hdfs文件的操作方法

《SpringBoot操作spark处理hdfs文件的操作方法》本文介绍了如何使用SpringBoot操作Spark处理HDFS文件,包括导入依赖、配置Spark信息、编写Controller和Ser... 目录SpringBoot操作spark处理hdfs文件1、导入依赖2、配置spark信息3、cont
阅读更多...
springboot整合 xxl-job及使用步骤

springboot整合 xxl-job及使用步骤

《springboot整合xxl-job及使用步骤》XXL-JOB是一个分布式任务调度平台,用于解决分布式系统中的任务调度和管理问题,文章详细介绍了XXL-JOB的架构,包括调度中心、执行器和Web... 目录一、xxl-job是什么二、使用步骤1. 下载并运行管理端代码2. 访问管理页面，确认是否启动成功
阅读更多...
Java中的密码加密方式

Java中的密码加密方式

《Java中的密码加密方式》文章介绍了Java中使用MD5算法对密码进行加密的方法,以及如何通过加盐和多重加密来提高密码的安全性,MD5是一种不可逆的哈希算法,适合用于存储密码,因为其输出的摘要长度固... 目录Java的密码加密方式密码加密一般的应用方式是总结Java的密码加密方式密码加密【这里采用的
阅读更多...
Java中ArrayList的8种浅拷贝方式示例代码

Java中ArrayList的8种浅拷贝方式示例代码

《Java中ArrayList的8种浅拷贝方式示例代码》：本文主要介绍Java中ArrayList的8种浅拷贝方式的相关资料,讲解了Java中ArrayList的浅拷贝概念,并详细分享了八种实现浅... 目录引言什么是浅拷贝？ArrayList 浅拷贝的重要性方法一：使用构造函数方法二：使用 addAll(
阅读更多...
解决mybatis-plus-boot-starter与mybatis-spring-boot-starter的错误问题

解决mybatis-plus-boot-starter与mybatis-spring-boot-starter的错误问题

《解决mybatis-plus-boot-starter与mybatis-spring-boot-starter的错误问题》本文主要讲述了在使用MyBatis和MyBatis-Plus时遇到的绑定异常... 目录myBATis-plus-boot-starpythonter与mybatis-spring-b
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2