#
集合可以理解为在内存中存放一组对象的容器，对象是数据的封装，而对象又构成了集合。在java中的集合框架是一种线性的数据结构，但是它分为两种，一种是物理结构，一种是逻辑结构。物理结构是一种连续存储的结构，比如说数组;而逻辑结构可以理解为在内存块中是不连续的，比如说链表，一个链表是分为两中内容的，一个是该链表所存储的数据，还有一个呢，那就是指向下一个链表的指针，通过指针而把表给连起来，称之为链表。数组其实也是可以完成像集合一样的存储的，但是数组存在一定的弊端，数组一旦创建，其大小，类型是固定的，在特定的情况下不能更方便的使用，因此，为了与数组互补，集合也就应运而生了。
在java.util包中存在三种最重要的集合，其分别是list，set，map，它们各自有各自的特点，这三种都是接口。其中list：1> list的实现类主要有ArrayList，Linkedlist及其Vector，list中存储的数据是有序的，而且也是可以重复的，也就是说list按照添加的顺序，依次的tb存储在list下标从小到大的位置。做一个简单的代码测试
public class Test {
public static void main(String[] args) {
Test test = new Test();
test.testList();
public void testList(){//类
//创建一个List对象
List list = new ArrayList();
list.add(1);
list.add(1);
list.add(2);
for(Object a:list){
System.out.print(a+" ");
}
}
此段代码的运行结果为：{1 1 2}
反应了其有序可重复的特点。
2>set同样是一个接口，它常用的实现类有Hashset，Treeset。set集合的存储特点可以说是和list完全相反的，它是一种无序而且不能重复的存储特点。同样的用代码做一个测试 public class Test {
public static void main(String[] args) {
Test test = new Test();
test.testSet();
public void testSet(){
//创建Set对象
Set set = new HashSet();
set.add(1);
set.add(2);
set.add(5);
set.add(3);
set.add(4);
set.add(1);
set.add(null);
System.out.println(set);
Iterator it = set.iterator();
while(it.hasNext()){//判断有元素可迭代
int i = it.next();
System.out.print(i+" ");
}
}
}
}
此段代码的运行结果是：{1 2 3 4 5}
可以说明其无序不可重复的特点。
3>最后则是map集合，map的实现类常用的有Hashmap，Hashtable和Treemap。
map与以上两者稍微的有点不同，它是一种映射关系，在map中，存储两种数据，tb表达为map，而以上两者都只有一个数据，而且都是通过下标来访问的，map中k是不可以重复的，而v是可以重复的，进行一段代码测试
public class Test{
public static void main(String[] args){
testmap test=new testmap();
public void testMap(){
Map map = new HashMap();
map.put(1, "aaa");
map.put(2, "bbb");
map.put(3,"ccc");
map.put(2, "ddd");
System.out.println(map);
//获取key集合(Set)
Set set = map.keySet();
Iterator it = set.iterator();
while(it.hasNext()){
int key = it.next();
//通过key获取对应的value值
String value = map.get(key);
System.out.println("key="+key+" value="+value);
}
}
}
}
此段代码的运行结果是：key=1 value=aaa;key=2 value=ddd;key=3 value=ccc。
这三种集合各有其所试用的地方，对于像我这种初学者可以让整个代码简化，思路更清晰。
二：获得各种数据存储方式长度的方法。
数组：定义一个数组Array[];那么获得该数组长度的方法是使用其length方法。
字符串： String st = "aaa";
st.length();
这里的length是字符串的一种属性，而数组的length是一种方法。
List：迭代或者直接通过下标输出，list.size()
set：迭代while(it.hasNext()){//判断有元素可迭代
int i = it.next();
System.out.print(i+" ");
}
map：只能用迭代的方法，
//获取key集合(Set)
Set set = map.keySet();
Iterator it = set.iterator();
while(it.hasNext()){
int key = it.next();
//通过key获取对应的value值
String value = map.get(key);
System.out.println("key="+key+" value="+value);
}
map先是通过迭代器先得到key值，因为是一种一一对应的关系，所以用key值就可以得到value值了。
先举个hibernate执行SQL的例子：
[java] view plaincopy
public boolean addUser(UserDO userDO) {
boolean b = false;
if (userDO != null) {
try {
getHibernateTemplate().save(userDO);
b = true;
} catch (Exception e) {
b = false;
}
} else {
b = false;
}
return b;
}
一、hibernate操作数据库的执行步骤，其实很简单，可以自己实现一个小的hibernate框架：
1、运用java反射机制，获得user对象的类型user.class
2、参考对象-关系映射元数据(可能是DO的spring注解，可能是hibernate配置文档)，找到和user类对应的表为user表，并建立对象域跟表属性的对应
3、根据以上映射信息，生成SQL语句
4、通过JDBC API来执行SQL语句
二、hibernate的核心接口：
1、Configuration接口：配置hibernate，根启动hibernate，创建sessionfactory对象。hibernate通过configuration实例来获得对象-关系映射文件中的元数据，以及动态的配置hibernate属性，然后创建sessionfactory实例。具体执行过程如下：
[java] view plaincopy
Configuration config=new Configuration();
创建configuration实例，configuration类的构造方法中把applicationContext.xml文档加载到内存，tb读取文档中sessionFactory Bean的配置。然后运用java反射机制，获得userDO对象的类型UserDO。configuration类的addClass方法
[java] view plaincopy
config.addClass(userDO.class);
该方法将hbm.xml文档或者通过hibernate注解形式的“对象-关系映射元数据”读入内存，找到和UserDO类对应的表为USER表，并建立对象域跟表属性的对应。
2、sessionfactory接口：初始化hibernate，充当数据存储源的代理，创建session对象。一个sessionfactory实例对应着一个数据存储源。重量级，一个数据库只创建一个sessionfactory实例，它需要一个很大的缓存，用来存放预定义的SQL语句及映射的元数据等。
3、session接口：负责保存、更新、删除、加载和查询对象。session对象不是线程安全的，因此应该避免过多个线程共享一个session实例。当session执行sql时候，session会针对上面生成的对象和关系映射，动态组成sql语句。
4、transaction：事务管理接口。它对底层的事务接口做了封装。
5、query：执行数据库查询。query实例封装了一个HQL语句，HQL语句是面向对象的，它引用类名和类的属性。
三、hibernate的使用步骤：
1、创建hibernate配置文件
2、创建持久化类
3、创建对象-关系映射文件
4、通过hibernate API编写数据库访问代码
1. 垃圾回收
JVM运行环境中垃圾对象的定义：
一个对象创建后被放置在JVM的堆内存(heap)中，当永远不再引用这个对象时，它将被JVM在堆内存(heap)中回收。被创建的对象不能再生，同时也没法通过程序语句释放它们。
不可到达的对象被JVM视为垃圾对象，JVM将给这些对象打上标记，然后清扫回收它们，并将散碎的内存单元收集整合。
JVM管理的两种类型的内存：
堆内存(heap)，主要存储程序在运行时创建或实例化的对象与变量。
栈内存(stack)，主要存储程序代码中声明为静态(static)(或非静态)的方法。
堆内存(heap)通常情况下被分为两个区域：新对象(new object)区域与老对象(old object)区域。
新对象区域：
又可细分为Eden区域、From区域与To区域。
Eden区域保存新创建的对象。当该区域中的对象满了后，JVM系统将做可达性测试，主要任务是检测有哪些对象由根集合出发是不可到达的，这些对象就可被JVM回收，且将所有的活动对象从Eden区域拷到To区域，此时有一些对象将发生状态交换，有的对象就从To区域被转移到From区域，此时From区域就有了对象。
该过程执行期间，JVM的性能非常低下，会严重影响到正在运行的应用的性能。
老对象区域：
在老对象区域中的对象仍有一个较长的生命周期。经过一段时间后，被转入
tb老对象区域的对象就变成了垃圾对象，此时它们被打上相应的标记，JVM将自动回收它们。
建议不要频繁强制系统做垃圾回收，因为JVM会利用有限的系统资源，优先完成垃圾回收工作，致使应用无法快速响应来自用户端的请求，这样会影响系统的整体性能。
2. JVM中对象的生命周期
对象的整个生命周期大致分为7个阶段：创建(creation)、应用(using)、不可视(invisible)、不可到达(unreachable)、可收集(collected)、终结(finalized)、释放(free)。
1) 创建阶段
系统通过下面步骤，完成对象的创建：
a) 为对象分配存储空间
b) 开始构造对象
c) 递归调用其超类的构造方法
d) 进行对象实例初始化与变量初始化
e) 执行构造方法体
在创建对象时的几个关键应用规则：
避免在循环体中创建对象，即使该对象占用内存空间不大
尽量及时使对象符合垃圾回收标准
不要采用过深的继承层次
访问本地变量优于访问类中的变量
该说的都在注释中说完了。直接给程序吧。
[java] view plaincopyprint?
package test.javaPuzzler.p5;
import java.io.*;
import java.io.ObjectInputStream.GetField;
import java.io.ObjectOutputStream.PutField;
// 转载请注明来自http://blog.csdn.net/sunxing007
// 一个类实现Serializable来表明自己可以被序列化;
// 有一点需要特别注意的是：
// 如果子类实现了Serializable，而父类没有，则父类不会被序列化;
public class SerializableObject implements Serializable {
// 生成的序列化版本号会因为编译环境，声明的类名，成员名称和数量的变化而不同;
// 也就是说这个版本号一定程度上记录着类的定义性的信息，如果类的定义变化了，最好重新生成版本号;
// 如果新的代码使用了旧的版本号，则在反序列化的时候，可以兼容读取旧类的字节码而不会报错;
private static final long serialVersionUID = 9038542591452547920L;
public String name;
public String password;
// 如果你不希望某个非静态成员被序列化，可以用transient来修饰它;
public transient int age;
// 静态成员不会被序列化，因为序列化保存的是实例的状态信息，而静态成员是类的状态信息;
public static int version = 1;
public SerializableObject(String name, String password) {
this.name = name;
this.password = password;
}
// 每个类可以写一个writeObject方法，这个方法将会负责该类自身的序列化过程;
// 比如对于敏感信息如password，可以加密之后再序列化;
// 这个过程需要用到PutField，它可以指定哪些域会被序列化，怎么序列化(比如加密);
// 如果没有定义这个方法，将会调用ObjectOutputStream 的 defaultWriteObject;
// 你可以注释掉readObject方法，然后运行测试用例来测试密码是否被加密;
private void writeObject(ObjectOutputStream out) throws IOException {
PutField putFields = out.putFields();
putFields.put("name", name);
// 模拟加密密码
putFields.put("password", "thePassword:" + password);
out.writeFields();
}
// 每个类可以写一个readObjectb方法，该方法负责该类自身的反序列化过程;
// 比如对序列化时加密后的密码解密;
// 这个过程需要用到GetField，他可以具体地读取每个域;或执行解密动作等等;
// 如果没有定义这个方法，将会调用ObjectInputStream 的 defaultReadObject;
private void readObject(ObjectInputStream in)
throws ClassNotFoundException, IOException {
GetField readFields = in.readFields();
// 读取到成员的值之后，直接赋给该域，即完成该域的反序列化;
name = (String) readFields.get("name", "defaultName");
// 模拟解密密码
String encPassword = (String) readFields.get("password",
"thePassword:defaultValue");
password = encPassword.split(":")[1];
}
// 序列化
// 主要用到ObjectOutputStream;
public void save() throws IOException {
FileOutputStream fout = new FileOutputStream("e:obj");
ObjectOutputStream oout = new ObjectOutputStream(fout);
oout.writeObject(this);
oout.close();
fout.close();
}
// 反序列化
// 主要用到ObjectInputStream
public static SerializableObject load() throws IOException,
ClassNotFoundException {
FileInputStream fin = new FileInputStream("e:obj");
ObjectInputStream oin = new ObjectInputStream(fin);
Object o = oin.readObject();
return (SerializableObject) o;
}
@Override
public String toString() {
return "name: " + name + ", password: " + password;
}
// tb测试用例
public static void main(String[] args) throws IOException,
ClassNotFoundException {
SerializableObject so = new SerializableObject(
"http://blog.csdn.net/sunxing007", "123456");
so.save();
System.out.println(so);
System.out.println(SerializableObject.load());
}
}
1.绝对值：abs()
select abs(-2) value from dual;
2.取整函数（大）：ceil（）
select ceil(-2.001) value from dual;(-2)
3.取整函数（小）：floor（）
select floor(-2.001) value from dual;(-3)
4.取整函数（截取）：trunc（）
select trunc(-2.001) value from dual; (-2)
5.四舍五入：round（）
select round(1.234564) value from dual;(1.2346)
6.取平方：Power（m,n）
select power(4,2) value from dual;(16)
7.取平方根:SQRT()
select sqrt(16) value from dual;(4)
8.取随机数:dbms_random(minvalue,maxvalue)
select sys.dbms.random.value(0,1) value from dual;
9.取符号：Sign()
select sign(-3) value from dual;(-)
10,取集合的最大值:greatest(value)
select greatest(-1,3,5,7,9) value from dual;(9)
11.取集合的最小值:least(value)
select least(-1,3,5,7,9) value from dual;(-1)
12.处理Null值：nvl(空值，代替值)
select nvl(null,10) value from dual;(10)
13.求字符序号:ascii()
select ascii(a) value from dual;
14.求序号字符:chr()
select chr(97) value from dual;
15.链接：concat()
select concat("11","22") value from dual;(1122)
16.获取系统时间:sysdate()
select sysdate value from dual;
17.求日期
select trunc(sysdate) from dual;
18.求时间
select to_char(sysdate,"hh24:mm:ss") from dual;
19.首字母大写：InitCAP()
select INITCAP(abc def ghi) value from dual;tbw(Abc Def Ghi)
Sapan Diwakar在过去几年间一直从事Android开发工作，同时他也积累了一些非常实用的Android应用开发资源，希望对你有所帮助。
1. Android AnnotationsAndroid Annotations是一个能够加速Android开发的开源框架，它可以帮助开发者处理一些前后台任务、rest服务、应用类、代码片段等，让开发者专注于真正重要的东西。
2. ActionBarSherlokActionBarSherlock是一个扩展的Android支持库，旨在允许开发者通过一个单一的API，在所有的Android版本中都能够非常方便地使用活动栏设计模式。
3. Spring AndroidJava开发者应该比较熟悉，这是一个针对Android开发的Spring框架。我使用最多的是RestTemplate功能，此外，AndroidAnnotations已经支持Spring Rest Template，使得编写REST客户端更加容易。
4. URLImageViewHelper如果你想在应用程序中通过URL来加载远程图像，这是最好的选择。URLImageViewHelper提供了辅助
tb类，可以很容易地加载远程图像，同时还提供了图像缓存功能。
5. SubtlePatternsSubtlePatterns提供了一些高质量的纹理图案资源，图案都非常适合作为应用背景，并且使用也很简单。你可以点击这里来看我如何在应用中使用这些图案。
6. Sliding Menu（滑动菜单）顾名思义，SlidingMenu是一个在Android应用中添加滑动菜单效果的库，尽管网上还有一些其他类似的库，但我发现从性能和易于集成方面，SlidingMenu是最好的。
7. Android ViewPagerIndicator一个非常棒的库，用于在一个多页面切换视图中指示当前的页面。
8. Vogella Android教程vogella团队几乎已经将Android开发中的所有事情做成了教程，对于开发入门非常有帮助。
9. Android-PullToRefresh针对Android的下拉刷新库。
10. 谷歌的Android教程开始Android开发必备的指南、培训资源。
11. Commonsware Github库几款Android应用开发库，可以使你的开发工作更加轻松。
你有什么好的资源，欢迎补充。
package com.hospital.dao.tools;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import org.apache.log4j.Logger;
/**
* 数据库操作管理类
*
* @author Harlyhood
*
*/
public class DBManager {
// --------------------------------------------------------- Instance
private static Logger logger = Logger.getLogger(DBManager.class);
// --------------------------------------------------------- Methods
// 数据库连接对象
private Connection con;
// SQL语句对象
private Statement stmt;
// 带参数的Sql语句对象
private PreparedStatement pstmt;
// 记录集对象
private ResultSet rs;
// 数据连接管理（连接池对象）
private DBConnectionManager dcm = null;
/** ***********************手动设置的连接参数********************************* */
@SuppressWarnings("unused")
private static String _DRIVER = "com.microsoft.sqlserver.jdbc.SQLServerDriver";
@SuppressWarnings("unused")
private static String _URL = "jdbc:sqlserver://localhost:1433;database=Hospital_AI_DB;characterEncoding=gb2312";
@SuppressWarnings("unused")
private static String _USER_NA = "sa";
@SuppressWarnings("unused")
private static String _PASSWORD = "";
/** ********************************************************************** */
// 默认构造
public DBManager() {
}
/** ****************************************************************************************** */
/**
* **************************************** 数据库连接初始化
* ***********************************
*/
/** ****************************************************************************************** */
/**
* 得到一个默认的数据库连接[从 com.hospital.dao.tools.db.properties文件初始化]
*
* @throws Exception
*/
private void getConnection() {
logger.info("###############open:::::从默认的配置文件得到一个数据库连接");
// 获取一个连接tb池管理类的实例
dcm = DBConnectionManager.getInstance();
// 得到一个数据库连接
con = dcm.getConnection("mysql");
try {
con.setAutoCommit(false);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 从指定参数得到一个连接对象
*
* @param driver
* @param url
* @param user_na
* @param password
* @throws Exception
*/
public void getConnection(String driver, String url, String user_na,
String password) throws Exception {
try {
logger.info("###############open:::::从指定配置中得到一个数据库连接");
Class.forName(driver);
con = DriverManager.getConnection(url, user_na, password);
} catch (ClassNotFoundException ex) {
logger
.info("###############Error[com.hospital.dao.tools.DBManager^^^Method:getConnection^^^Line:81]找不到类驱动类: "
+ driver);
throw ex;
} catch (SQLException ex) {
logger
.info("###############Error[com.hospital.dao.tools.DBManager^^^Method:getConnection^^^Line:81]加载类: "
+ driver + " 时出现 SQLException 异常");
throw ex;
}
}
/** ****************************************************************************************** */
/**
* **************************************** 数据库操作方法
* ***********************************
*/
/** ****************************************************************************************** */
/**
* 执行SQL语句操作(更新数据 无参数)
*
* @param strSql
* SQL语句
* @throws Exception
*/
public boolean executeUpdate(String strSql) throws SQLException {
getConnection();
// getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
boolean flag = false;
stmt = con.createStatement();
logger.info("###############::执行SQL语句操作(更新数据 无参数):" + strSql);
try {
if (0 < stmt.executeUpdate(strSql)) {
close_DB_Object();
flag = true;
con.commit();
}
} catch (SQLException ex) {
logger
.info("###############Error DBManager Line126::执行SQL语句操作(更新数据 无参数):"
+ strSql + "失败!");
flag = false;
con.rollback();
throw ex;
}
return flag;
}
/**
* 执行SQL语句操作(更新数据 有参数)
*
* @param strSql
* sql指令
* @param prams
* 参数列表
* @return
* @throws SQLException
*/
public boolean executeUpdate(String strSql, HashMap<Integer, Object> prams)
throws SQLException, ClassNotFoundException {
getConnection();
// getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
boolean flag = false;
try {
pstmt = con.prepareStatement(strSql);
setParamet(pstmt, prams);
logger.info("###############::执行SQL语句操作(更新数据 有参数):" + strSql);
if (0 < pstmt.executeUpdate()) {
close_DB_Object();
flag = true;
con.commit();
}
} catch (SQLException ex) {
logger
.info("###############Error DBManager Line121::执行SQL语句操作(更新数据 无参数):"
+ strSql + "失败!");
flag = false;
con.rollback();
throw ex;
} catch (ClassNotFoundException ex) {
logger
.info("###############Error DBManager Line152::执行SQL语句操作(更新数据 无参数):"
+ strSql + "失败! 参数设置类型错误!");
con.rollback();
throw ex;
}
return flag;
}
/**
* 执行SQL语句操作(查询数据 无参数)
*
* @param strSql
* SQL语句
* @return 数组对象列表
* @throws Exception
*/
public ArrayList<HashMap<Object, Object>> executeSql(String strSql)
throws Exception {
getConnection();
// getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
stmt = con.createStatement();
logger.info("###############::执行SQL语句操作(查询数据):" + strSql);
rs = stmt.executeQuery(strSql);
con.commit();
if (null != rs) {
return convertResultSetToArrayList(rs);
}
close_DB_Object();
return null;
}
/**
* 执行SQL语句操作(查询数据 有参数)
*
* @param strSql
* SQL语句
* @param prams
* 参数列表
* @return 数组对象列表
* @throws Exception
*/
public ArrayList<HashMap<Object, Object>> executeSql(String strSql,
HashMap<Integer, Object> prams) throws Exception {
getConnection();
// getConnection(_DRIVER,_URL,_USER_NA,_PASSWORD);
pstmt = con.prepareStatement(strSql);
setParamet(pstmt, prams);
logger.info("###############::执行SQL语句操作(查询数据):" + strSql);
rs = pstmt.executeQuery();
con.commit();
if (null != rs) {
return convertResultSetToArrayList(rs);
}
return null;
}
/**
* 执行存储过程(查询数据 无参数)
*
* @param procName
* 存储过程名称
* @return 数组列表对象
* @throws Exception
*/
public ArrayList<HashMap<Object, Object>> executeProcedureQuery(
String procName) throws Exception {
getConnection();// 获取连接
String callStr = "{call " + procName + "}";// 构造执行存储过程的sql指令
CallableStatement cs = con.prepareCall(callStr);
logger.info("###############::执行存储过程(查询数据):" + procName);
rs = cs.executeQuery();
con.commit();
cs.close();
close_DB_Object();
return convertResultSetToArrayList(rs);
}
/**
* 执行存储过程(查询数据,带参数)返回结果集合
*
* @param procName
* 存储过程名称
* @param parameters
* 参数对象数组
* @param al
* 数组列表对象
* @return 数组列表对象
* @throws Exception
*/
public ArrayList<HashMap<Object, Object>> executeProcedureQuery(
String procName, Object[] parameters) throws Exception {
int parameterPoint = 0;
// 获取存储过程信息列表集合
ArrayList<HashMap<Object, Object>> procedureInfo = getProcedureInfo(procName);
// 获取存储过程的完全名称
String procedureCallName = getProcedureCallName(procName,parameters.length);
// 获取连接对象
getConnection();
// 初始化 存储过程 执行对象
CallableStatement cs = con.prepareCall(procedureCallName);
// 参数下标变量
int index = 0;
// 获取 存储过程信息列表集合的 迭代器 对象
Iterator<HashMap<Object, Object>> iter = procedureInfo.iterator();
// 遍历存储过程信息列表集合
while (iter.hasNext()) {
HashMap<Object, Object> hm = iter.next();
parameterPoint++;
// 如果参数是输入参数 way = 0
if (hm.get("WAY").equals("0")) {
// 设置参数到cs
cs.setObject(parameterPoint, parameters[index]);
// 参数下标+1
index++;
}
}
// 释放这个对象,做为第二次使用
procedureInfo = null;
logger.info("###############::执行存储过程(查询数据):::::" + procedureCallName);
rs = cs.executeQuery();
con.commit();
procedureInfo = convertResultSetToArrayList(rs);
cs.close();
close_DB_Object();
return procedureInfo;
}
/**
* 执行存储过程(更新，查询数据[简单查询、非纪录集]，返回输出参数[非纪录集])
*
* @param procName
* 存储过程名称
* @param parameters
* 参数对象数组
* @param os
* 输出参数对象数组
* @return 输出参数对象数组
* @throws Exception
*/
public Object[] executeProcedureUpdate(String procName, Object[] parameters)
throws Exception {
logger.info("------------------------------------------------------------------------------------------------------");
logger.info(" Run --> executeProcedureUpdate ############## 正在执行 存储过程: " + procName +" ##############");
CallableStatement cs = null;
Object []returnVal = null;
try {
// 获取 存储过程 调用全名
String fullPCallName = getProcedureCallName(procName,parameters.length);
logger.info(" Run --> executeProcedureUpdate # 存储过程命令: " + fullPCallName +" #");
//获取存储过程参数信息
ArrayList<HashMap<Object, Object>> p_Call_Info_List = getProcedureInfo(procName);
//获取连接
getConnection();
//创建 存储过程 执行对象
cs = con.prepareCall(fullPCallName);
//数组下标
int index = 1;
//输出参数下标 纪录
ArrayList<Integer> outPutIndexList = new ArrayList<Integer>();
logger.info(" Run --> executeProcedureUpdate # 参数个数是: " + parameters.length +" #");
for(HashMap<Object,Object> tempHash:p_Call_Info_List)
{
if("0".equals(tempHash.get("WAY")))
{
//设置输入参数
cs.setObject(index, parameters[index-1]);
logger.info(" Run --> executeProcedureUpdate # 输入 Input: 编号:" + index +" 值: "+parameters[index-1]+" 类型: "+parameters[index-1].getClass()+" #");
}
else
{
//注册输出参数
cs.registerOutParameter(index, getDataType(tempHash.get("TYPENAME").toString()));
//纪录输出参数的下标
outPutIndexList.add(index);
logger.info(" Run --> executeProcedureUpdate # 输出 OutPut: 编号:" + index +" 值: "+parameters[index-1]+" 类型: "+parameters[index-1].getClass()+" #");
}
index++;
}
logger.info(" Run --> executeProcedureUpdate # 参数设置完毕,正在执行中 : #");
//-------------------- 执行 -----------------
if(!cs.execute())
{
returnVal = new Object[outPutIndexList.size()];
logger.info(" Run --> executeProcedureUpdate # 执行成功! : #");
//取输 出参数的 返回值
for(int i = 0 ;i<outPutIndexList.size();i++)
{
returnVal[i] = cs.getObject(outPutIndexList.get(i));
logger.info(" Run --> executeProcedureUpdate # 返回值 "+(i+1)+" "+returnVal[i]+" #");
}
con.commit();//提交
}
} catch (Exception e) {
logger.info(" Run --> executeProcedureUpdate # 执行失败!事务回滚中 : #");
con.rollback();
throw e;
}
logger.info("------------------------------------------------------------------------------------------------------");
return returnVal;
}
/** ****************************************************************************************** */
/**
* ********************************* 小工具
* ************************************************
*/
/** ****************************************************************************************** */
/**
* 关闭数据对象
*/
public void close_DB_Object() {
logger.info("###############close:::::关闭连接对象，语句对象，记录集对象");
if (null != rs) {
try {
rs.close();
} catch (SQLException ex) {
rs = null;
}
}
if (null != stmt) {
try {
stmt.close();
} catch (SQLException ex) {
stmt = null;
}
}
if (null != pstmt) {
try {
pstmt.close();
} catch (SQLException ex) {
pstmt = null;
}
}
if (con != null) {
dcm.freeConnection("mysql", con);
}
}
/**
* 设置Sql 指令参数
*
* @param p_stmt
* PreparedStatement
* @param pramets
* HashMap
*/
private PreparedStatement setParamet(PreparedStatement p_stmt,
HashMap<Integer, Object> pramets) throws ClassNotFoundException,
SQLException {
// 如果参数为空
if (null != pramets) {
// 如果参数个数为0
if (0 <= pramets.size()) {
for (int i = 1; i <= pramets.size(); i++) {
try {
// 字符类型 String
if (pramets.get(i).getClass() == Class
.forName("java.lang.String")) {
p_stmt.setString(i, pramets.get(i).toString());
}
// 日期类型 Date
if (pramets.get(i).getClass() == Class
.forName("java.sql.Date")) {
p_stmt.setDate(i, java.sql.Date.valueOf(pramets
.get(i).toString()));
}
// 布尔类型 Boolean
if (pramets.get(i).getClass() == Class
.forName("java.lang.Boolean")) {
p_stmt.setBoolean(i, (Boolean) (pramets.get(i)));
}
// 整型 int
if (pramets.get(i).getClass() == Class
.forName("java.lang.Integer")) {
p_stmt.setInt(i, (Integer) pramets.get(i));
}
// 浮点 float
if (pramets.get(i).getClass() == Class
.forName("java.lang.Float")) {
p_stmt.setFloat(i, (Float) pramets.get(i));
}
// 双精度型 double
if (pramets.get(i).getClass() == Class
.forName("java.lang.Double")) {
p_stmt.setDouble(i, (Double) pramets.get(i));
}
} catch (ClassNotFoundException ex) {
throw ex;
} catch (SQLException ex) {
throw ex;
}
}
}
}
return p_stmt;
}
/**
* 转换记录集对象为数组列表对象
*
* @param rs
* 纪录集合对象
* @return 数组列表对象
* @throws Exception
*/
private ArrayList<HashMap<Object, Object>> convertResultSetToArrayList(
ResultSet rs) throws Exception {
logger.info("###############::转换记录集对象为数组列表对象");
// 获取rs 集合信息对象
ResultSetMetaData rsmd = rs.getMetaData();
// 创建数组列表集合对象
ArrayList<HashMap<Object, Object>> tempList = new ArrayList<HashMap<Object, Object>>();
HashMap<Object, Object> tempHash = null;
// 填充数组列表集合
while (rs.next()) {
// 创建键值对集合对象
tempHash = new HashMap<Object, Object>();
for (int i = 0; i < rsmd.getColumnCount(); i++) {
// 遍历每列数据，以键值形式存在对象tempHash中
tempHash.put(rsmd.getColumnName(i + 1).toUpperCase(), rs
.getString(rsmd.getColumnName(i + 1)));
}
// 第一个键值对，存储在tempList列表集合对象中
tempList.add(tempHash);
}
close_DB_Object();// 关闭相关链接
return tempList;// 返回填充完毕的数组列表集合对象
}
/**
* 从数据库得到tb存储过程信息
*
* @param procName
* 存储过程名称
* @return 数组列表对象
* @throws Exception
*/
private ArrayList<HashMap<Object, Object>> getProcedureInfo(String procName)
throws Exception {
return this.executeSql("select Syscolumns.isoutparam as Way,systypes.name as TypeName from sysobjects,syscolumns,systypes where systypes.xtype=syscolumns.xtype and syscolumns.id=sysobjects.id and sysobjects.name='"
+ procName + "' order by Syscolumns.isoutparam");
}
/**
* 从数据库得到存储过程参数个数
*
* @param procName
* 存储过程名称
* @return 数组列表对象
* @throws Exception
*/
@SuppressWarnings("unused")
private int getParametersCount(String procName) throws Exception {
int returnVal = 0;
for (HashMap<Object, Object> tempHas : this
.executeSql("select count(*) as RowsCount from sysobjects,syscolumns,systypes where systypes.xtype=syscolumns.xtype and syscolumns.id=sysobjects.id and sysobjects.name='"
+ procName + "'")) {
returnVal = Integer.parseInt(tempHas.get("ROWSCOUNT").toString());
}
return returnVal;
}
/**
* 得到调用存储过程的全名
*
* @param procName
* 存储过程名称
* @return 调用存储过程的全名
* @throws Exception
*/
private String getProcedureCallName(String procName, int prametCount)
throws Exception {
String procedureCallName = "{call " + procName;
for (int i = 0; i < prametCount; i++) {
if (0 == i) {
procedureCallName = procedureCallName + "(?";
}
if (0 != i) {
procedureCallName = procedureCallName + ",?";
}
}
procedureCallName = procedureCallName + ")}";
return procedureCallName;
}
/**
* 得到数据类型的整型值
*
* @param typeName
* 类型名称
* @return 数据类型的整型值
*/
private int getDataType(String typeName) {
if (typeName.equals("varchar"))
return Types.VARCHAR;
if (typeName.equals("int"))
return Types.INTEGER;
if (typeName.equals("bit"))
return Types.BIT;
if (typeName.equals("float"))
return Types.FLOAT;
return 0;
}
// 设置驱动路径
@SuppressWarnings("static-access")
public void set_DRIVER(String _DRIVER) {
this._DRIVER = _DRIVER;
}
// 设置数据库密码
@SuppressWarnings("static-access")
public void set_PASSWORD(String _PASSWORD) {
this._PASSWORD = _PASSWORD;
}
// 设置数据库连接字符串
@SuppressWarnings("static-access")
public void set_URL(String _URL) {
this._URL = _URL;
}
// 设置数据库用户名
@SuppressWarnings("static-access")
public void set_USER_NA(String _USER_NA) {
this._USER_NA = _USER_NA;
}
}
function coun
tbCharacters(str)
{
var totalCount = 0;
for (var i=0; i<str.length; i++)
{
var c = str.charCodeAt(i);
if ((c >= 0x0001 && c <= 0x007e) || (0xff60<=c && c<=0xff9f))
{
totalCount++;
}
else
{
totalCount+=2;
}
}
return totalCount;
}
<script type="text/javascript">
//一个汉字相当于2个字符
function get_length(s){
var char_length = 0;
for (var i = 0; i < s.length; i++){
var son_char = s.charAt(i);
encodeURI(son_char).length > 2 ? char_length += 1 : char_length += 0.5;
}
return char_length;
}
function cut_str(stbr, len){
var char_length = 0;
for (var i = 0; i < str.length; i++){
var son_str = str.charAt(i);
encodeURI(son_str).length > 2 ? char_length += 1 : char_length += 0.5;
if (char_length >= len){
var sub_len = char_length == len ? i+1 : i;
return str.substr(0, sub_len);
break;
}
}
}
// 截取15个字（30个字符）
// cut_str('aa啊啊啊啊啊啊啊啊啊啊啊啊啊k的啊是', 15);
</script>
-
- *
- * 处理过长的字符串，截取并添加省略号
- * 注：半角长度为1，全角长度为2
- *
- * pStr:字符串
- * pLen:截取长度
- *
- * return: 截取后的字符串
- *
- function autoAddEllipsis(pStr, pLen) {
-
- var _ret = cutString(pStr, pLen);
- var _cutFlag = _ret.cutflag;
- var _cutStringn = _ret.cutstring;
-
- if ("1" == _cutFlag) {
- return _cutStringn + "...";
- } else {
- return _cutStringn;
- }
- }
-
- *
- * 取得指定长度的字符串
- * 注：半角长度为1，全角长度为2
- *
- * pStr:字符串
- * pLen:截取长度
- *
- * return: 截取后的字符串
- *
- function cutString(pStr, pLen) {
-
- // 原字符串长度
- var _strLen = pStr.length;
-
- var _tmpCode;
-
- var _cutString;
-
- // 默认情况下，返回的字符串是原字符串的一部分
- var _cutFlag = "1";
-
- var _lenCount = 0;
-
- var _ret = false;
-
- if (_strLen <= pLen/2) {
- _cutString = pStr;
- _ret = true;
- }
-
- if (!_ret) {
- for (var i = 0; i < _strLen ; i++ ) {
- if (isFull(pStr.charAt(i))) {
- _lenCount += 2;
- } else {
- _lenCount += 1;
- }
-
- if (_lenCount > pLen) {
- _cutString = pStr.substring(0, i);
- _ret = true;
- break;
- } else if (_lenCount == pLen) {
- _cutString = pStr.substring(0, i + 1);
- _ret = true;
- break;
- }
- }
- }
-
- if (!_ret) {
- _cutString = pStr;
- _ret = true;
- }
-
- if (_cutString.length == _strLen) {
- _cutFlag = "0";
- }
-
- return {"cutstring":_cutString, "cutflag":_cutFlag};
- }
-
- *
- * 判断是否为全角
- *
- * pChar:长度为1的字符串
- * return: tbtrue:全角
- * false:半角
- *
-
- function isFull (pChar) {
- for (var i = 0; i < pChar.strLen ; i++ ) {
- if ((pChar.charCodeAt(i) > 128)) {
- return true;
- } else {
- return false;
- }
- }
- }
- 用例：
- testStr = "测试1字符串";
autoAddEllipsis(testStr, 1); // "测..."
autoAddEllipsis(testStr, 2); // "测..."
autoAddEllipsis(testStr, 3); // "测..."
autoAddEllipsis(testStr, 4); // "测试..."
autoAddEllipsis(testStr, 5); // "测试1..."
autoAddEllipsis(testStr, 6); // "测试1..."
autoAddEllipsis(testStr, 7); // "测试1字..."