#
集合可以理解為在內存中存放一組對象的容器，對象是數據的封裝，而對象又構成了集合。在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字..."