少年阿宾

Java动态代理实现

Kongxx

在目前的Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。

其实现主要通过是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现，如下，HelloWorld接口定义的业务方法，HelloWorldImpl是HelloWorld接口的实现，HelloWorldHandler是InvocationHandler接口实现。代码如下：

业务接口:

public interface HelloWorld {        void sayHelloWorld() ; }

业务接口实现：

public class HelloWorldImpl implements HelloWorld {          public void sayHelloWorld() {               System.out.println("Hello World!");                    } }

InvocationHandler实现，需要在接口方法调用前后加入一部份处理工作，这里仅仅在方法调用前后向后台输出两句字符串，其代码如下：

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class HelloWorldHandler implements InvocationHandler {        //要代理的原始对象        private Object objOriginal;        /**         * 构造函数。         * @param obj 要代理的原始对象。         */        public HelloWorldHandler(Object obj) {               this.objOriginal = obj ;        }        public Object invoke(Object proxy, Method method, Object[] args)                      throws Throwable {                             Object result ;                       //方法调用之前               doBefore();                       //调用原始对象的方法               result = method.invoke(this.objOriginal ,args);                       //方法调用之后               doAfter();                             return result ;        }               private void doBefore() {               System.out.println("before method invoke!");        }               private void doAfter() {               System.out.println("after method invoke!");        } }

测试代码：

import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy;             public class Test {                    public static void main(String[] args) {                           HelloWorld hw = new HelloWorldImpl();                             InvocationHandler handler = new HelloWorldHandler(hw);                             HelloWorld proxy = (HelloWorld) Proxy.newProxyInstance(                             hw.getClass().getClassLoader(),                             hw.getClass().getInterfaces(),                             handler);                 proxy.sayHelloWorld();        } }

Ø         首先获取一个业务接口的实现对象；

Ø         获取一个InvocationHandler实现，此处是HelloWorldHandler对象；

Ø         创建动态代理对象；

Ø         通过动态代理对象调用sayHelloWorld()方法，此时会在原始对象HelloWorldImpl. sayHelloWorld()方法前后输出两句字符串。

运行测试类输出如下:

before method invoke! Hello World! after method invoke!

此处Test类中的方法调用代码比较多，在我们的实际应用中可以通过配置文件来来简化客户端的调用实现。另外也可以通过动态代理来实现简单的AOP。

http://www.cnblogs.com/kongxx/archive/2005/08/08/209749.html 

     摘要: 要对资料库管理系统进行操作，最基本的就是使用SQL（Standard Query Language）语句，大部份的资料库都支援标准的SQL语句，然而也有一些特定于资料库的SQL语句，应用程式配合SQL语句进行资料库查询时，若使用到特定于资料库的SQL语句，程式本身会有相依于特定资料库的问题。使用Hibernate时，即使您不了解SQL的使用与撰写，也可以使用它所提供的API来进行SQL语句查询，o...  阅读全文

hibernate 中 Criteria 的使用介绍

http://blog.csdn.net/alex197963/article/details/2628196

有俩种方法:
一种是声明系统游标,一种是声明自定义游标,然后后面操作一样,参数类型为
in out 或out
(1)声明个人系统游标.(推荐)
create or replace p_temp_procedure
(
    cur_arg out sys_refcursor;     --方法1
)
begin
    open cur_arg for select * from tablename;
end
调用
declare
    cur_calling sys_refcursor;
begin
    p_temp_procedure(cur_calling);  --这样这个游标就有值了
    for rec_next in cur_calling loop
     ....
    end loop;
end;










create or replace procedure getList(id in varchar2,mycur out sys_refcursor)
is
v_sql varchar2(4000);
begin
dbms_output.put_line('call it success');
v_sql:='select * from userbean s where s.id=:1';
open mycur for v_sql using id;
commit;
end;



create or replace procedure my_procedure
(mypageNo number,mypageSize number,myInfo_Cursor out sys_refcursor)
as
pageNO number;
pageSize number;

begin
open myInfo_Cursor for
select * from product
where pid between 1 + (pageNo - 1) * pageSize and 4 + (pageNo - 1) * pageSize;

end;




declare
my_cursor sys_refcursor;
begin
my_procedure(1,2,my_cursor);
for rec_next in my_cursor loop
dbms_output.put_line('pid:'||rec_next.pid||'  ptypeid:'||rec_next.ptypeid||'  proname:'||rec_next.proname||'  price:'||rec_next.price||'  pronum:'||rec_next.pronum);
end loop;
end;

package com.abin.lee.bean;

/**
 * Userbean entity. @author MyEclipse Persistence Tools
 */

public class UserBean implements java.io.Serializable {

 // Fields

 private String id;
 private String username;
 private String password;

 // Constructors

 /** default constructor */
 public UserBean() {
 }

 /** minimal constructor */
 public UserBean(String id) {
  this.id = id;
 }

 /** full constructor */
 public UserBean(String id, String username, String password) {
  this.id = id;
  this.username = username;
  this.password = password;
 }

 // Property accessors

 public String getId() {
  return this.id;
 }

 public void setId(String id) {
  this.id = id;
 }

 public String getUsername() {
  return this.username;
 }

 public void setUsername(String username) {
  this.username = username;
 }

 public String getPassword() {
  return this.password;
 }

 public void setPassword(String password) {
  this.password = password;
 }

}

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="com.abin.lee.bean.UserBean" table="USERBEAN" schema="ABING">
        <id name="id" type="string">
            <column name="ID" length="80" />
            <generator class="assigned" />
        </id>
        <property name="username" type="string">
            <column name="USERNAME" length="80" />
        </property>
        <property name="password" type="string">
            <column name="PASSWORD" length="80" />
        </property>
    </class>
</hibernate-mapping>

package com.abin.lee.dao;

import java.sql.SQLException;

import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class UserDao {
 private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
 private static SessionFactory sessionFactory;
 static {
  sessionFactory=new Configuration().configure().buildSessionFactory();
 }
 public static Session GetSession(){
  Session session=(Session)threadLocal.get();
  if(null == session|| !session.isOpen()){
   if(null==sessionFactory){
    sessionFactory=new Configuration().configure().buildSessionFactory();
   }
   session=(sessionFactory!=null)?sessionFactory.openSession():null;
   threadLocal.set(session);
  }
  return session;
 }
 
 public static int insert(String id,String usr,String pwd) throws SQLException{
  UserDao UserDao=new UserDao();
  Session session=UserDao.GetSession();
  Transaction tx=session.beginTransaction();
  SQLQuery sqlQuery = session.createSQLQuery("{call insertObj(?,?,?)}");
  sqlQuery.setParameter(0, id);
  sqlQuery.setParameter(1, usr);
  sqlQuery.setParameter(2, pwd);
  int result=sqlQuery.executeUpdate();
  System.out.println("result="+result);
  return result;
 }
 
}

package com.abin.lee.test;

import java.sql.SQLException;

import junit.framework.TestCase;

import com.abin.lee.dao.UserDao;

public class UserTest extends TestCase{
 public void test() throws SQLException{
  UserDao user=new UserDao();
  int success=user.insert("abin","abing","bing");
  System.out.println("success="+success);
 }
}

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

 <session-factory>
  <property name="dialect">
   org.hibernate.dialect.OracleDialect
  </property>
  <property name="connection.url">
   jdbc:oracle:thin:@localhost:1521:xe
  </property>
  <property name="connection.username">abing</property>
  <property name="connection.password">abing</property>
  <property name="connection.driver_class">
   oracle.jdbc.driver.OracleDriver
  </property>
  <property name="myeclipse.connection.profile">
   OracleConnection
  </property>
  <mapping resource="com/abin/lee/bean/UserBean.hbm.xml" />
   
    </session-factory>

</hibernate-configuration>

create index aid on abin(id)
create unique index usid on abin(sid)
//组合索引
create unique index allindex on abin(id,name,sid)
http://blog.csdn.net/java05/article/details/5579183

创建主键：
create table abin1(
id number(10,0) not null check(id>0),
name nvarchar2(100),
constraint abin1id primary key(id)
);

创建主键和外键
create table abin2(
id number(10,0) not null check(id>0),
sid number(10,0) not null,
name nvarchar2(100),
constraint abin2id primary key(id),
constraint abin2sid foreign key(sid) references abin1(id)
)

约束作用：用来保持数据的完整性，防止无效数据进入到数据库中。
oracle数据库中提供的5种约束,都是限定某个列或者列的组合的。
1、主键约束(PRIMARY KEY)：
在一个表中能唯一的标识一行。主键可以限定在多个列上。
3、唯一键约束(UNIQUE key)：在一个表中能唯一的标识一行，唯一键也可以限定在多个列上。
主键和唯一键的区别：
a、一个表中最多只能有一个主键。可以多个唯一键。
b、主键所限定的列不能为null,唯一键所限定的列可以为null.
2、外键约束(FOREIGN key)：
   引用表：有外键约束的列所在的表。
   被引用表：外键所引用的列。被引用的列只能是主键或者唯一键。
4、非空约束(NOT null)：表示该列上的数据不能有null值。
5、检查性约束(check)：表示该列上的数据必须满足某一个条件表达式。

如何创建约束：
1、在创建表的同时创建约束
   a.列级别约束：在每个列写完之后写约束。
          CREATE TABLE t_08132(id NUMBER(10) PRIMARY KEY ,
                                NAME CHAR(10) NOT NULL,
                                gender CHAR(2) CHECK (gender IN ('男','女')),
                                email CHAR(20) UNIQUE
                                )
          INSERT INTO t_08132 VALUES(1,'a','男','1@neusoft.com')                               
          INSERT INTO t_08132 VALUES(2,'a','男','2@neusoft.com')                               
          INSERT INTO t_08132 VALUES(3,'c','男','3@neusoft.com')                               
          INSERT INTO t_08132 VALUES(4,'d','','4@neusoft.com')                               
          INSERT INTO t_08132 VALUES(5,'e','妖','5@neusoft.com')       
          //外键约束
          CREATE TABLE t_08133( id NUMBER(10) PRIMARY KEY ,
                                NAME CHAR(10) NOT NULL,
                                deptno NUMBER(2) REFERENCES dept(deptno)                               
                                )
          INSERT INTO t_08133 VALUES(1,'a',20) 
          //给约束命名         
          CREATE TABLE t_08134(id NUMBER(10) CONSTRAINT t4_id_pk PRIMARY KEY ,
                                NAME CHAR(10) CONSTRAINT t4_name_nn NOT NULL,
                                gender CHAR(2) CONSTRAINT t4_gen_ck CHECK (gender IN ('男','女')),
                                email CHAR(20) CONSTRAINT t4_em_uk UNIQUE,
                                deptno NUMBER(2) CONSTRAINT t4_deptno_fk REFERENCES dept(deptno)                               
                                )
          INSERT INTO t_08134 VALUES(5,'e','男','5@neusoft.com',NULL)                      
          INSERT INTO t_08134 VALUES(6,'e','男','6@neusoft.com',NULL)                      
   b.表级别约束：在所有列写完之后写约束。注意，notnull约束不能写在表级别上。
      CREATE TABLE t_08135(id NUMBER(10)  ,
                                NAME CHAR(10) CONSTRAINT t5_name_nn NOT NULL,
                                gender CHAR(2) ,
                                email CHAR(20) ,
                                deptno NUMBER(2) ,
                                CONSTRAINT t5_id_pk PRIMARY KEY (ID),
                                CONSTRAINT t5_gen_ck CHECK (gender IN ('男','女')),
                                CONSTRAINT t5_em_uk UNIQUE(email),
                                CONSTRAINT t5_deptno_fk FOREIGN KEY (deptno) REFERENCES dept(deptno)                               
                               )
约束的名字：一般规则 约束所在的表_约束所在的列_约束类型
 emp_empno_pk,通常只给主键、外键、唯一键命名。

2、在创建表之后创建约束
语法：
Alter TABLE 表名 ADD [CONSTRAINT 约束名] 约束类型 [(列名列表)]
CREATE TABLE t08161 (ID NUMBER,NAME CHAR(10),sex CHAR(2) ,email CHAR(10),deptno NUMBER)
//在ID字段上添加主键约束
ALTER TABLE t08161 ADD CONSTRAINT t1_id_pk PRIMARY KEY(ID)
//在sex字段上添加检查性约束
ALTER TABLE t08161 ADD CONSTRAINT t1_email_ck CHECK (sex IN ('男','女'))
//在email上添加唯一性约束
ALTER TABLE t08161 ADD CONSTRAINT t1_email_uk UNIQUE (email)
//在deptno上添加外键约束,引用于dept的deptno字段。
ALTER TABLE t08161 ADD CONSTRAINT t1_deptno_fk FOREIGN KEY (deptno) REFERENCES dept(deptno)
//在name上添加非空约束
ALTER TABLE t08161 ADD CONSTRAINT t1_name_nn NOT NULL (NAME)    //加不上

ALTER TABLE t08161 MODIFY NAME NULL  
ALTER TABLE 表名 MODIFY 字段名 NULL/NOT NULL   //通过该语法设置某一个字段为null或者not NULL.
//练习：
创建表学生表，里面包含学号（主键），姓名（非空),年龄,入班日期，
班级编号（外键，引用于dept表部门编号）
要求，在创建完表之后建立约束。
CREATE TABLE t08162 (sno NUMBER ,sname CHAR(10) ,sage NUMBER ,indate DATE,classno NUMBER)
ALTER TABLE t08162 ADD PRIMARY KEY (sno)
ALTER TABLE t08162 MODIFY sNAME NOT NULL
ALTER TABLE t08162 ADD FOREIGN KEY(classno) REFERENCES dept(deptno)
4、如何删除约束
ALTER TABLE 表名 DROP PRIMARY KEY|UNIQUE (列)|CONSTRAINT 约束名
ALTER TABLE t08162 DROP PRIMARY KEY
练习：删除t08162上的classno上的外键约束
ALTER TABLE t08162 DROP CONSTRAINT sys_c005467
5、约束的启用和禁用。
语法：
Alter TABLE 表名 Disable|ENABLE CONSTRAINT 约束名

2．索引作用

在索引列上，除了上面提到的有序查找之外，数据库利用各种各样的快速定位技术，能够大大提高查询效率。特别是当数据量非常大，查询涉及多个表时，使用索引往往能使查询速度加快成千上万倍。

例如，有3个未索引的表t1、t2、t3，分别只包含列c1、c2、c3，每个表分别含有1000行数据组成，指为1～1000的数值，查找对应值相等行的查询如下所示。

 

SELECT c1,c2,c3 FROM t1,t2,t3 WHERE c1=c2 AND c1=c3

此查询结果应该为1000行，每行包含3个相等的值。在无索引的情况下处理此查询，必须寻找3个表所有的组合，以便得出与WHERE子句相配的那些行。而可能的组合数目为1000×1000×1000（十亿），显然查询将会非常慢。

如果对每个表进行索引，就能极大地加速查询进程。利用索引的查询处理如下。

（1）从表t1中选择第一行，查看此行所包含的数据。

（2）使用表t2上的索引，直接定位t2中与t1的值匹配的行。类似，利用表t3上的索引，直接定位t3中与来自t1的值匹配的行。

（3）扫描表t1的下一行并重复前面的过程，直到遍历t1中所有的行。

在此情形下，仍然对表t1执行了一个完全扫描，但能够在表t2和t3上进行索引查找直接取出这些表中的行，比未用索引时要快一百万倍。

利用索引，MySQL加速了WHERE子句满足条件行的搜索，而在多表连接查询时，在执行连接时加快了与其他表中的行匹配的速度。

13.4.2 创建索引

在执行CREATE TABLE语句时可以创建索引，也可以单独用CREATE INDEX或ALTER TABLE来为表增加索引。

1．ALTER TABLE

ALTER TABLE用来创建普通索引、UNIQUE索引或PRIMARY KEY索引。

 

ALTER TABLE table_name ADD INDEX index_name (column_list)

ALTER TABLE table_name ADD UNIQUE (column_list)

ALTER TABLE table_name ADD PRIMARY KEY (column_list)

 

其中table_name是要增加索引的表名，column_list指出对哪些列进行索引，多列时各列之间用逗号分隔。索引名index_name可选，缺省时，MySQL将根据第一个索引列赋一个名称。另外，ALTER TABLE允许在单个语句中更改多个表，因此可以在同时创建多个索引。

2．CREATE INDEX

CREATE INDEX可对表增加普通索引或UNIQUE索引。

 

CREATE INDEX index_name ON table_name (column_list)

CREATE UNIQUE INDEX index_name ON table_name (column_list)

 

table_name、index_name和column_list具有与ALTER TABLE语句中相同的含义，索引名不可选。另外，不能用CREATE INDEX语句创建PRIMARY KEY索引。

3．索引类型

在创建索引时，可以规定索引能否包含重复值。如果不包含，则索引应该创建为PRIMARY KEY或UNIQUE索引。对于单列惟一性索引，这保证单列不包含重复的值。对于多列惟一性索引，保证多个值的组合不重复。

PRIMARY KEY索引和UNIQUE索引非常类似。事实上，PRIMARY KEY索引仅是一个具有名称PRIMARY的UNIQUE索引。这表示一个表只能包含一个PRIMARY KEY，因为一个表中不可能具有两个同名的索引。

下面的SQL语句对students表在sid上添加PRIMARY KEY索引。

 

ALTER TABLE students ADD PRIMARY KEY (sid)

 

13.4.3 删除索引

可利用ALTER TABLE或DROP INDEX语句来删除索引。类似于CREATE INDEX语句，DROP INDEX可以在ALTER TABLE内部作为一条语句处理，语法如下。

 

DROP INDEX index_name ON talbe_name

ALTER TABLE table_name DROP INDEX index_name

ALTER TABLE table_name DROP PRIMARY KEY

 

其中，前两条语句是等价的，删除掉table_name中的索引index_name。

第3条语句只在删除PRIMARY KEY索引时使用，因为一个表只可能有一个PRIMARY KEY索引，因此不需要指定索引名。如果没有创建PRIMARY KEY索引，但表具有一个或多个UNIQUE索引，则MySQL将删除第一个UNIQUE索引。

如果从表中删除了某列，则索引会受到影响。对于多列组合的索引，如果删除其中的某列，则该列也会从索引中删除。如果删除组成索引的所有列，则整个索引将被删除