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 NoClassDefFoundError运行时错误分析解决

Java NoClassDefFoundError运行时错误分析解决

《JavaNoClassDefFoundError运行时错误分析解决》在Java开发中,NoClassDefFoundError是一种常见的运行时错误,它通常表明Java虚拟机在尝试加载一个类时未能... 目录前言一、问题分析二、报错原因三、解决思路检查类路径配置检查依赖库检查类文件调试类加载器问题四、常见
阅读更多...
Java注解之超越Javadoc的元数据利器详解

Java注解之超越Javadoc的元数据利器详解

《Java注解之超越Javadoc的元数据利器详解》本文将深入探讨Java注解的定义、类型、内置注解、自定义注解、保留策略、实际应用场景及最佳实践,无论是初学者还是资深开发者,都能通过本文了解如何利用... 目录什么是注解？注解的类型内置注编程解自定义注解注解的保留策略实际用例最佳实践总结在 Java 编程
阅读更多...
Java 实用工具类Spring 的 AnnotationUtils详解

Java 实用工具类Spring 的 AnnotationUtils详解

《Java实用工具类Spring的AnnotationUtils详解》Spring框架提供了一个强大的注解工具类org.springframework.core.annotation.Annot... 目录前言一、AnnotationUtils 的常用方法二、常见应用场景三、与 JDK 原生注解 API 的
阅读更多...
Java controller接口出入参时间序列化转换操作方法(两种)

Java controller接口出入参时间序列化转换操作方法(两种)

《Javacontroller接口出入参时间序列化转换操作方法(两种)》：本文主要介绍Javacontroller接口出入参时间序列化转换操作方法,本文给大家列举两种简单方法,感兴趣的朋友一起看... 目录方式一、使用注解方式二、统一配置场景：在controller编写的接口，在前后端交互过程中一般都会涉及
阅读更多...
Java中的StringBuilder之如何高效构建字符串

Java中的StringBuilder之如何高效构建字符串

《Java中的StringBuilder之如何高效构建字符串》本文将深入浅出地介绍StringBuilder的使用方法、性能优势以及相关字符串处理技术,结合代码示例帮助读者更好地理解和应用,希望对大家... 目录关键点什么是 StringBuilder？为什么需要 StringBuilder？如何使用 St
阅读更多...
使用Java将各种数据写入Excel表格的操作示例

使用Java将各种数据写入Excel表格的操作示例

《使用Java将各种数据写入Excel表格的操作示例》在数据处理与管理领域,Excel凭借其强大的功能和广泛的应用,成为了数据存储与展示的重要工具,在Java开发过程中,常常需要将不同类型的数据,本文... 目录前言安装免费Java库1. 写入文本、或数值到 Excel单元格2. 写入数组到 Excel表格
阅读更多...
Java并发编程之如何优雅关闭钩子Shutdown Hook

Java并发编程之如何优雅关闭钩子Shutdown Hook

《Java并发编程之如何优雅关闭钩子ShutdownHook》这篇文章主要为大家详细介绍了Java如何实现优雅关闭钩子ShutdownHook,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起... 目录关闭钩子简介关闭钩子应用场景数据库连接实战演示使用关闭钩子的注意事项开源框架中的关闭钩子机制1.
阅读更多...
Python中pywin32 常用窗口操作的实现

Python中pywin32 常用窗口操作的实现

《Python中pywin32常用窗口操作的实现》本文主要介绍了Python中pywin32常用窗口操作的实现,pywin32主要的作用是供Python开发者快速调用WindowsAPI的一个... 目录获取窗口句柄获取最前端窗口句柄获取指定坐标处的窗口根据窗口的完整标题匹配获取句柄根据窗口的类别匹配获取句
阅读更多...
Maven中引入 springboot 相关依赖的方式(最新推荐)

Maven中引入 springboot 相关依赖的方式(最新推荐)

《Maven中引入springboot相关依赖的方式(最新推荐)》：本文主要介绍Maven中引入springboot相关依赖的方式(最新推荐),本文给大家介绍的非常详细,对大家的学习或工作具有... 目录Maven中引入 springboot 相关依赖的方式1. 不使用版本管理（不推荐）2、使用版本管理（推
阅读更多...
Java 中的 @SneakyThrows 注解使用方法(简化异常处理的利与弊)

Java 中的 @SneakyThrows 注解使用方法(简化异常处理的利与弊)

《Java中的@SneakyThrows注解使用方法(简化异常处理的利与弊)》为了简化异常处理,Lombok提供了一个强大的注解@SneakyThrows,本文将详细介绍@SneakyThro... 目录1. @SneakyThrows 简介 1.1 什么是 Lombok？2. @SneakyThrows
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2