hibernate动态数据库进化版

最新推荐文章于 2024-03-18 17:59:28 发布
置顶 最新推荐文章于 2024-03-18 17:59:28 发布
阅读量2k 收藏 2
点赞数 1
分类专栏： hibernate Java 文章标签： Hibernate java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hellojava1234/article/details/9949359
版权

闲言少叙：


import org.hibernate.HibernateException;
import org.hibernate.cfg.Configuration;

/**
 * Hibernate配置
 * @author chendaojun
 *
 */
public class DynamicHibernateConfiguration extends Configuration {
	public DynamicHibernateConfiguration() {
		super();
	}

	public void reset() {
		super.reset();
	}

	public DynamicHibernateConfiguration(String dialect, String driverClass,
			String ipAddress, String port, String dataBaseName,
			String username, String password) throws HibernateException {
		String connection_url = "";
		if (dialect.indexOf("MySQL") > -1) {
			connection_url = "jdbc:mysql://" + ipAddress + "/" + dataBaseName;
		} else if (dialect.indexOf("SQLServer") > -1) {
			connection_url = "jdbc:sqlserver://" + ipAddress + ":" + port
					+ ";DataBaseName=" + dataBaseName;
		} else if (dialect.indexOf("Oracle") > -1) {
			connection_url = "jdbc:oracle:thin:@" + ipAddress + ":" + port
					+ ":" + dataBaseName;
		} else {
			throw new HibernateException("The dialect was not allowed.==fd=="
					+ dialect);
		}
		super.setProperty("hibernate.connection.provider_class","com.jolbox.bonecp.provider.BoneCPConnectionProvider");
		super.setProperty("hibernate.dialect", dialect);
		super.setProperty("hibernate.connection.url", connection_url);
		super.setProperty("hibernate.connection.driver_class", driverClass);
		super.setProperty("hibernate.connection.username", username);
		super.setProperty("hibernate.connection.password", password);
		super.setProperty("bonecp.idleMaxAge", "60");
		super.setProperty("bonecp.idleConnectionTestPeriod", "5");
		super.setProperty("bonecp.maxConnectionsPerPartition", "60");
		super.setProperty("bonecp.minConnectionsPerPartition", "20");
		super.setProperty("bonecp.partitionCount", "3");
		super.setProperty("bonecp.acquireIncrement", "10");
		super.setProperty("bonecp.statementsCacheSize", "50");
		super.setProperty("bonecp.preparedStatementCacheSize", "50");
		super.setProperty("bonecp.releaseHelperThreads", "3");
		super.setProperty("bonecp.connectionTestStatement", "select 1 from dual");
//		super.setProperty("hibernate.show_sql", "true");    
	}

	public DynamicHibernateConfiguration(String dialect, String driverClass,
			String ipAddress, String port, String dataBaseName,
			String username, String password, String schema, String catalog)
			throws HibernateException {
		String connection_url = "";
		if (dialect.indexOf("MySQL") > -1) {
			connection_url = "jdbc:mysql://" + ipAddress + "/" + dataBaseName;
		} else if (dialect.indexOf("SQLServer") > -1) {
			connection_url = "jdbc:sqlserver://" + ipAddress + ":" + port
					+ ";DataBaseName=" + dataBaseName;
		} else if (dialect.indexOf("Oracle") > -1) {
			connection_url = "jdbc:oracle:thin:@" + ipAddress + ":" + port
					+ ":" + dataBaseName;
		} else {
			throw new HibernateException("The dialect was not allowed.==fd=="
					+ dialect);
		}
		super.setProperty("hibernate.connection.provider_class","com.jolbox.bonecp.provider.BoneCPConnectionProvider");
		super.setProperty("hibernate.dialect", dialect);
		super.setProperty("hibernate.connection.url", connection_url);
		super.setProperty("hibernate.connection.driver_class", driverClass);
		super.setProperty("hibernate.connection.username", username);
		super.setProperty("hibernate.connection.password", password);
		super.setProperty("hibernate.default_schema", schema);
//		super.setProperty("hibernate.default_catalog", catalog);
//		super.setProperty("hibernate.show_sql", "true");   
		super.setProperty("bonecp.idleMaxAge", "60");
		super.setProperty("bonecp.idleConnectionTestPeriod", "5");
		super.setProperty("bonecp.maxConnectionsPerPartition", "60");
		super.setProperty("bonecp.minConnectionsPerPartition", "20");
		super.setProperty("bonecp.partitionCount", "3");
		super.setProperty("bonecp.acquireIncrement", "10");
		super.setProperty("bonecp.statementsCacheSize", "50");
		super.setProperty("bonecp.preparedStatementCacheSize", "50");
		super.setProperty("bonecp.releaseHelperThreads", "3");
		super.setProperty("bonecp.connectionTestStatement", "select 1 from dual");
	}

}





import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
/**
 * 动态会话工厂类
 * @author 陈道俊改进版
 *
 */
public class DynamicSessionFactory {    
	   
//    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";    
    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();    
    private static DynamicHibernateConfiguration configuration = new DynamicHibernateConfiguration();    
    private static org.hibernate.SessionFactory sessionFactory;    
    private static List<DynamicHibernateConfiguration> configurationList = new ArrayList<DynamicHibernateConfiguration>();
    private static Map<String, SessionFactory> sessinFactoryMap = new HashMap<String, SessionFactory>();
//    private static String configFile = CONFIG_FILE_LOCATION;    
   
   /* static {    
        try {    
    		configuration.configure(configFile);    
    		sessionFactory = configuration.buildSessionFactory();    
        } catch (Exception e) {    
            System.err.println("%%%% 创建临时会话工厂错误 %%%%");    
            e.printStackTrace();    
        }    
    }*/    
   
    private DynamicSessionFactory() {    
    }    
   
    /**   
     * Returns the ThreadLocal Session instance. Lazy initialize the   
     * <code>SessionFactory</code> if needed.   
     *    
     * @return Session   
     * @throws HibernateException   
     */   
    public static Session getSession() throws HibernateException {    
        Session session = (Session) threadLocal.get();    
   
        if (session == null || !session.isOpen()) {    
            if (sessionFactory == null) {    
                rebuildSessionFactory();    
            }    
            session = (sessionFactory != null) ? sessionFactory.openSession()    
                    : null;    
            threadLocal.set(session);    
        }    
   
        return session;    
    }    
   
    /**   
     * Rebuild hibernate session factory   
     *    
     */   
    public static void rebuildSessionFactory() {    
        try {    
            // configuration.configure(configFile);    
            sessionFactory = configuration.buildSessionFactory();    
        } catch (Exception e) {    
            System.err.println("%%%% 重建临时会话工厂错误 %%%%");    
            e.printStackTrace();    
        }    
    }    
   
    public static void reflashSessionFactory(    
            DynamicHibernateConfiguration tempConfiguration) {    
        try {    
            // configuration.configure(configFile);
        	
        	// hibernate配置相同的标志
        	boolean flag = false; 
        	for (DynamicHibernateConfiguration config : configurationList) {
        		if (tempConfiguration.getProperty("hibernate.dialect").equals(config.getProperty("hibernate.dialect"))    
                    && tempConfiguration.getProperty("hibernate.connection.url").equalsIgnoreCase(config.getProperty("hibernate.connection.url"))    
                    && tempConfiguration.getProperty("hibernate.connection.username").equals(config.getProperty("hibernate.connection.username"))    
                    && tempConfiguration.getProperty("hibernate.connection.password").equals(config.getProperty("hibernate.connection.password"))) {    
                    configuration = config;
                    sessionFactory = sessinFactoryMap.get(configuration.getProperty("hibernate.connection.url")+configuration.getProperty("hibernate.connection.username"));
                    flag = true;
                    break;
        		}
			}
        	if (!flag){    
                closeSession();    
                closeSessionFactory();    
                configuration.reset();    
                configuration = tempConfiguration;    
                configurationList.add(configuration);
                sessionFactory = configuration.buildSessionFactory();
                sessinFactoryMap.put(configuration.getProperty("hibernate.connection.url")+configuration.getProperty("hibernate.connection.username"), sessionFactory);
//                System.out.println("%%%% 会话工厂在这里重新开始 %%%%");    
            }    
        } catch (Exception e) {    
            System.err.println("%%%% 会话工厂重新开始错误 %%%%");    
            e.printStackTrace();    
        }    
    }    
   
    public static void closeSessionFactory() throws HibernateException {    
        try {
        	if (sessionFactory != null) {
        		sessionFactory.close();    
			}
        } catch (Exception e) {    
            System.err.println("%%%% 会话工厂关闭错误 %%%%");    
            e.printStackTrace();    
        }    
    }    
   
    /**   
     * Close the single hibernate session instance.   
     *    
     * @throws HibernateException   
     */   
    public static void closeSession() throws HibernateException {    
        Session session = (Session) threadLocal.get();    
        threadLocal.set(null);    
   
        if (session != null) {    
            session.close();    
        }    
    }    
   
    /**   
     * return session factory   
     *    
     */   
    public static org.hibernate.SessionFactory getSessionFactory() {    
        return sessionFactory;    
    }    
   
    /**   
     * return session factory   
     *    
     * session factory will be rebuilded in the next call   
     */   
    /*public static void setConfigFile(String configFile) {    
        TempSessionFactory.configFile = configFile;    
        sessionFactory = null;    
    }*/    
   
    /**   
     * return hibernate configuration   
     *    
     */   
    public static DynamicHibernateConfiguration getConfiguration() {    
        return configuration;    
    }    
   
}  








import java.util.List;
import java.util.Map;
import java.util.Set;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.transform.Transformers;


/**
 * 数据库操作
 * 
 * @author 陈道俊改进版
 * 
 */
public class DynamicHibernateDAO {
	public Session session = null;


	private Query query = null;;

	/**
	 * @param Dialect
	 *            //数据库方言
	 * @param dbDriver
	 *            //数据驱动
	 * @param dbUrl
	 *            //数据库地址
	 * @param DbPort
	 *            //数据库端口
	 * @param DbName
	 *            //数据库名
	 * @param DbUserName
	 *            //数据库用户名
	 * @param DbUserPassword
	 *            //数据库密码
	 * @return
	 */
	public DynamicHibernateConfiguration setHibernateConfig(String dialect,
			String driverClass, String ipAddress, String port,
			String dataBaseName, String username, String password,
			String schema, String catalog) {
		DynamicHibernateConfiguration configuration = null;
		if (schema != null && schema != "") {
			configuration = new DynamicHibernateConfiguration(dialect,
					driverClass, ipAddress, port, dataBaseName, username,
					password, schema, catalog);
		} else {
			configuration = new DynamicHibernateConfiguration(dialect,
					driverClass, ipAddress, port, dataBaseName, username,
					password);
		}
		return configuration;
	}

	/**
	 * 获取session
	 * 
	 * @return
	 */
	public void reflashDbConnection(
			DynamicHibernateConfiguration configuration, String dialect,
			String driverClass, String ipAddress, String port,
			String dataBaseName, String username, String password,
			String tableName) {

		session = DynamicSessionFactory.getSession();

	}

	public Session getSession() {
		return session;
	}

	/**
	 * 获取sqlSession
	 * 
	 * @return
	 */
	public Session getTempSession() {
		return DynamicSessionFactory.getSession();
	}


	/**
	 * 执行数据库操作时先执行此方法
	 * 
	 * @param dialect
	 * @param driverClass
	 * @param ipAddress
	 * @param port
	 * @param dataBaseName
	 * @param username
	 * @param password
	 * @param schema
	 * @param catalog
	 * @param tableName
	 */
	public void dynamicSqlOperateBefore(String dialect, String driverClass,
			String ipAddress, String port, String dataBaseName,
			String username, String password, String schema, String catalog,
			String tableName) {

		DynamicHibernateConfiguration configuration = setHibernateConfig(
				dialect, driverClass, ipAddress, port, dataBaseName, username,
				password, schema, catalog);
		DynamicSessionFactory.reflashSessionFactory(configuration);
		session = DynamicSessionFactory.getSession();
	}

	/**
	 * 获取对象
	 * @param dialect
	 * @param driverClass
	 * @param ipAddress
	 * @param port
	 * @param dataBaseName
	 * @param username
	 * @param password
	 * @param schema
	 * @param catalog
	 * @param tableName
	 * @param idColumn
	 * @param id
	 * @return
	 */
	public Object get(String dialect, String driverClass, String ipAddress,
			String port, String dataBaseName, String username, String password,
			String schema, String catalog, String tableName, String idColumn,
			Long id) {
		dynamicSqlOperateBefore(dialect, driverClass, ipAddress, port,
				dataBaseName, username, password, schema, catalog, tableName);
		StringBuilder sql = new StringBuilder();
		sql.append("select * from " + tableName + " where " + idColumn + "="
				+ id);
		query = session.createSQLQuery(sql.toString()).setResultTransformer(
				Transformers.ALIAS_TO_ENTITY_MAP);
		Object object = query.uniqueResult();

		// session.close();
		return object;
	}

	/**
	 * 获取对象列表
	 * @param dialect
	 * @param driverClass
	 * @param ipAddress
	 * @param port
	 * @param dataBaseName
	 * @param username
	 * @param password
	 * @param schema
	 * @param catalog
	 * @param tableName
	 * @param sortColumn
	 * @param params
	 * @param iDisplayStart
	 * @param iDisplayLength
	 * @return
	 */
	public List<Map<String, Object>> getObjectList(String dialect, String driverClass,
			String ipAddress, String port, String dataBaseName,
			String username, String password, String schema, String catalog,
			String tableName, String sortColumn, Map<String, String> params,
			Integer iDisplayStart, Integer iDisplayLength) {
		dynamicSqlOperateBefore(dialect, driverClass, ipAddress, port,
				dataBaseName, username, password, schema, catalog, tableName);

		if (iDisplayStart == null) {
			iDisplayStart = 1;
			if (iDisplayLength == null) {
				iDisplayLength = 10;
			}
		}
		StringBuilder sql = new StringBuilder();
		String dbType = DynamicSessionFactory.getConfiguration().getProperty("hibernate.connection.driver_class");
		if (dbType.contains("oracle")) {
			// oracle分页
			sql.append("select * from(select A.*, rownum rn from (");
		} else if(dbType.contains("mysql")) {
		}
		sql.append("select * from " + tableName + " where 1=1");
		if (params != null) {
			if (!params.isEmpty()) {
				Set<String> keys = params.keySet();
				for (String paramKey : keys) {
					String paramVal = params.get(paramKey);
					sql.append(" and " + paramKey + "='" + paramVal + "'");
				}
			}
		}
		
		if (sortColumn != null && sortColumn != "") {
			sql.append(" order by "+sortColumn+" desc");
		}
		
		if (dbType.contains("oracle")) {
			sql.append(") A where rownum <= " + iDisplayLength + ") where rn >= "
					+ iDisplayStart);
		} else if(dbType.contains("mysql")) {
			// mysql分页
			sql.append(" limit "+iDisplayStart+" ,"+iDisplayLength);
		}
		
		query = session.createSQLQuery(sql.toString()).setResultTransformer(
				Transformers.ALIAS_TO_ENTITY_MAP);
		List<Map<String, Object>> list = query.list();

		return list;
	}

	/**
	 * 记录总数查询
	 * @param dialect
	 * @param driverClass
	 * @param ipAddress
	 * @param port
	 * @param dataBaseName
	 * @param username
	 * @param password
	 * @param schema
	 * @param catalog
	 * @param tableName
	 * @param params
	 * @param iDisplayStart
	 * @param iDisplayLength
	 * @return
	 */
	public int getTotalCount(String dialect, String driverClass,
			String ipAddress, String port, String dataBaseName,
			String username, String password, String schema, String catalog,
			String tableName, Map<String, String> params,
			Integer iDisplayStart, Integer iDisplayLength) {
		 dynamicSqlOperateBefore(dialect, driverClass, ipAddress, port,
		 dataBaseName, username, password, schema, catalog, tableName);

		StringBuilder sql = new StringBuilder();
		sql.append("select count(*) from " + tableName);
		query = session.createSQLQuery(sql.toString());
		int totalCount = ((Number) query.uniqueResult()).intValue();
		return totalCount;
	}

}




import java.util.Map;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.transform.Transformers;

public class DynamicHibernateTest {
	public static void main(String[] args) {  
	    try{  
	          
	        Session session=null;
	          
	        // oracle
	        DynamicHibernateConfiguration configuration1 = new DynamicHibernateConfiguration("org.hibernate.dialect.OracleDialect","oracle.jdbc.driver.OracleDriver",  
	                "ip","1521","orcl","uname","pwd");  
	        System.out.println("hibernate.connection.url==1="+DynamicSessionFactory.getConfiguration().getProperty("hibernate.connection.url"));  
	        DynamicSessionFactory.reflashSessionFactory(configuration1);             
	        System.out.println("hibernate.connection.url==2="+DynamicSessionFactory.getConfiguration().getProperty("hibernate.connection.url"));  
	          
	        session=DynamicSessionFactory.getSession();  
	        Query query1 = session.createSQLQuery("select * from WCMDBA.WCM_NEWS where NID=20825").setResultTransformer(  
	                Transformers.ALIAS_TO_ENTITY_MAP);  
	        Map obj1 = (Map)query1.setMaxResults(1).uniqueResult();  
	        System.out.println("fd1111===="+obj1.get("NID"));  
	  
	          
	          
	        // mysql  
	        System.out.println("hibernate.connection.url==3="+DynamicSessionFactory.getConfiguration().getProperty("hibernate.connection.url"));  
	        DynamicHibernateConfiguration configuration2 = new DynamicHibernateConfiguration("org.hibernate.dialect.MySQLInnoDBDialect","com.mysql.jdbc.Driver",  
	                "127.0.0.1","3306","mobileCampus","root","root");              
	        DynamicSessionFactory.reflashSessionFactory(configuration2);  
	          
	        System.out.println("hibernate.connection.url==4="+DynamicSessionFactory.getConfiguration().getProperty("hibernate.connection.url"));  
	        session=DynamicSessionFactory.getSession();  
	        Query query2 = session.createSQLQuery("select * from phone_app ").setResultTransformer(  
	                Transformers.ALIAS_TO_ENTITY_MAP);  
	        Map obj2 = (Map)query2.setMaxResults(1).uniqueResult();  
	        System.out.println("fd2222===="+obj2.get("app_id"));  
	          
	    }catch (Exception e) {  
	        System.err.println(e);  
	    }  
	} 
}








参考：http://feicer.iteye.com/blog/583079


资源地址：http://download.csdn.net/detail/hellojava1234/5926509












                

        

        

    

  


    

      

        

            

              
                
                  coollor
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
hibernate动态数据源配置(注解)

				
			

			

				

					bvcxz10328的专栏
				

				

					01-12
					
					2497
					
				

			

		

		

			
				
1.首先需要一个 数据源类型的类。
 public enum DBType {
      dataSource, frontDataSource;
}
2.需要一个本地线程变量对象保存 数据源类型，这里使用的 是ThreadLocal，因为ThreadLocal 可以为每个线程单独创立一个新的副本变量。
public class ContextHolder {
    private

			
		

	



                

              
                



	

		

			

				
					
hibernate动态链接数据库配置文件问题

				
			

			

				

					靓仔！——没错！我叫你呢！
				

				

					04-09
					
					816
					
				

			

		

		

			
				
有时候在用hibernate连接数据库时会将用户名和密码都保存在hibernate.cfg.xml这个文件中，这样每次连接数据库时都用里面的用户名和密码，但是如果用于别的机器上，恰巧数据库的用户名和密码不是配置文件中的内容，则会无法连接。如要修改，只能手动重新修改这个配置文件，这样非常麻烦。于是我写了一个工具类，用于在程序中动态修改用户名和密码，这样在需要调用时就直接调用方法即可。
个人建议在连

			
		

	



                


  
              

                


	

		

			

				
					
动态Hibernate配置类

				
			

			

				

					AbsenceOfTrace的博客
				

				

					07-24
					
					568
					
				

			

		

		

			
				
package com.allimu.dao;import org.hibernate.HibernateException;
import org.hibernate.cfg.Configuration;
public class DynamicHibernateConfiguration extends Configuration {
    public DynamicHibernateCon

			
		

	





	

		

			

				
					
hibernate的Configuration和配置文件

				
			

			

				

					angji2879的博客
				

				

					04-14
					
					460
					
				

			

		

		

			
				
一、hibernate的入口Configuration
  
  在Hibernate中，Configuration是hibernate的入口。在实例化一个Configuration的时候，Hibernate会自动在环境变量（classpath）里面查找Hibernate配置文件hibernate.properties。如果该文件存在，则将该文件的内容加载到一个Pr...

			
		

	



		

			
		



	

		

			

				
					
hibernate动态读取配置及创建数据源

				
			

			

				

					人生如逆旅，我亦是行人。。。
				

				

					09-19
					
					1054
					
				

			

		

		

			
				
public static Configuration initDBConfig(String dialect, String driver, String url, String user, String pwd){
		Configuration cfg = new Configuration().configure("/hibernate.cfg.xml");
		cfg.setProper

			
		

	





	

		

			

				
					
数据库国产化探究及升级改造过程指导

					
最新发布

				
			

			

				

					企业实战系列集 ●●● https://ximenjianxue.blog.csdn.net
				

				

					03-18
					
					1974
					
				

			

		

		

			
				
当前官网最新版本为DM8，相较于目前主流产品架构：不同特性依靠不同内核去实现，DM8独特采用了双存储引擎架构，行存储引擎和列存储引擎可相互配合、协同工作。同时实现了计算层和存储层的分离，同一内核既支持共享存储式集群，也支持分布式事务集群。

			
		

	





	

		

			

				
					
hibernate的优化与事务

				
			

			

				

					youngboby的博客
				

				

					09-25
					
					381
					
				

			

		

		

			
				
1 延迟加载


（1）定义：当真正需要数据时才从数据中加载数据，目的就是为了提高执行效率。

  注意：当加载延迟加载的数据时，Session关闭，那么就会出现no session的异常，从而导致延迟加载的数据,无法加载。

（2）延迟加载的分类：
  
  1 实体级别： 此只对load方法有效。




  2 集合级别：


 
    extra：除了

			
		

	





	

		

			

				
					
进化中Hibernate3脚本

				
			

			

				

					zgqtxwd的专栏
				

				

					05-01
					
					274
					
				

			

		

		

			
				
<!--google_ad_client = "pub-2947489232296736";/* 728x15, 创建于 08-4-23MSDN */google_ad_slot = "3624277373";google_ad_width = 728;google_ad_height = 15;//--><script type="text/javascript"

			
		

	





	

		

			

				
					
从JDBC到Mybatis

				
			

			

				

					weixin_47593895的博客
				

				

					01-05
					
					240
					
				

			

		

		

			
				
文章目录一.为什么要抛弃JDBC这样传统的数据库访问模式而进化到数据持久层框架Mybatis或Hibernate二.在IDEA环境下以Mybatis为例对比说明Mybatis对JDBC的改造1.在IDEA中使用JDBC操作数据库2.在IDEA中使用Mybatis操作数据库3.从JDBC到Mybatis的改进四.参考链接
一.为什么要抛弃JDBC这样传统的数据库访问模式而进化到数据持久层框架Mybatis或Hibernate
首先观察JDBC对数据库进行访问的代码
package test1package;


			
		

	





	

		

			

				
					
达梦 Hibernate 方言 2.0 至 4.0

				
			

			

				

					03-26
				

			

		

		

			
				
5. **新功能支持**：随着Hibernate的进化，新版本的方言也会引入对如批处理操作、存储过程调用等新功能的支持，使开发者能更好地利用达梦数据库的高级特性。  6. **错误修复**：每个版本迭代通常会包含对已知问题的...

			
		

	





	

		

			

				
					
Struts2+Hibernate学生成绩管理系统

				
			

			

				

					11-19
				

			

		

		

			
				
在本系统中，Hibernate负责将学生对象、成绩对象等持久化到数据库中，无需编写繁琐的SQL语句。开发者只需要定义对象和数据库表的映射关系，就可以方便地进行增删查改操作。例如，当学生信息发生变化时，Hibernate会...

			
		

	





	

		

			

				
					
Hibernate3.3.rar

				
			

			

				

					06-08
				

			

		

		

			
				
《深入理解Hibernate 3.3：企业级持久化框架解析》  Hibernate，作为一个开源的对象关系映射（ORM）框架，自其诞生以来就受到了广大Java...同时，随着技术的发展，Hibernate也在不断进化，以适应不断变化的开发需求。

			
		

	





	

		

			

				
					
身份验证之绝对验证

				
			

			

				

					HelloJava1234的专栏
				

				

					04-08
					
					3300
					
				

			

		

		

			
				
import java.util.Calendar;
import java.util.Scanner;

public class ValidateID {
	/*
	 * 我国现行使用公民身份证号码有两种尊循两个国家标准，〖GB 11643-1989〗和〖GB 11643-1999〗。
	 * 〖GB 11643-1989〗中规定的是15位身份证号码：排列顺序从左至右依次为：六位数字地址码，六

			
		

	





	

		

			

				
					
身份证验证之简单校验

				
			

			

				

					HelloJava1234的专栏
				

				

					04-08
					
					3114
					
				

			

		

		

			
				
import java.util.Calendar;
import java.util.Scanner;

public class ValidateID {
   /*
     * 我国现行使用公民身份证号码有两种尊循两个国家标准，〖GB 11643-1989〗和〖GB 11643-1999〗。
     * 〖GB 11643-1989〗中规定的是15位身份证号码：排列顺序从左至右依次为：六

			
		

	





	

		

			

				
					
对于求字符串中出现频率最高字符的算法实现

				
			

			

				

					HelloJava1234的专栏
				

				

					05-25
					
					1691
					
				

			

		

		

			
				
好久没写文章了，今天写了“求字符串中出现频率最高字符”的一个算法实现，代码中有非常详细思路注释
本算法只是此问题一种解法，还有许多需要改进的地方，但这是个人目前想到的比较好的解决方案
如有更好的解决方案，多谢指正！
以下代码仅供参考
 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Coll

			
		

	





	

		

			

				
					
身份证验证之校验码算法验证

				
			

			

				

					HelloJava1234的专栏
				

				

					04-08
					
					1663
					
				

			

		

		

			
				
import java.util.Calendar;
import java.util.Scanner;

public class ValidateID {

	public static void main(String[] args) {
		ValidateID vid=new ValidateID();
		System.out.println("输入身份证号码：");
		Scanne

			
		

	





	

		

			

				
					
java操作pdf文件

				
			

			

				

					HelloJava1234的专栏
				

				

					08-04
					
					1522
					
				

			

		

		

			
				
要读取pdf文件，必须有pdfbox1.7.1.jar和fontbox1.7.1.jar，可以到官网下，也可以到我的资源里下，下面代码
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

import org.apache.pdfbox.pdmodel.PDDocument;
im

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值