hibernate防sql注入
⑴ hibernate操作数据库，用占位符有什么好处与直接拼字符串相比有什么好处
1.层次清晰，HQL长了之后代码也不显得乱
2.确实可以提高一定效率
3.安全性考虑，防止一些注入性攻击， 举个例子如果你的租含ruleCode变量从jsp页面获得，是客户手动输入的，那么客户如果恶意的输入一些特殊的字符 如 'or'='or' 那么你的HQL解析成sql就变成
select * from CategoryRule vc where vc.ruleCode = ‘哗握or’='or' ，如果这是用户名或者密码， 这样可能就能非法登录系统 ，或者获得后台一些数据错误信息的反馈。
采用setString就会把'or'='or' 整体当成一个串，就弊芦笑不会出现这种问题
⑵ java怎样过滤危险字符，该怎么解决
就WEB应用来说，所谓危险的字符一般就是两种
一个是SQL注入，一个是HTML语法注入
SQL注入主流的框架都可以搞定，JDBC永远都使用preparedstatement就可以防止所有的sql注入，关键是用户输入都要通过占位符往里放，就自动的替换掉了特殊字符了。hibernate等orm框架都会搞定这个问题
HTML语法注入是指用户输入的html代码回显出来，这样如果不转义就可以破坏页面的结构或者注入脚本。所以现在的网站都不允许用户直接输入html代码了，现在都是一些UBB标签来完成一些效果。HTML主要最好的解决办法是在回显的时候进行转义，所有的MVC框架或者展示层框架都有HTML转义的支持，包括struts,spring,volicty等，注意观察他们用于显示的标签
⑶ java拼接sql怎么防止注入
使用Hibernate框架的SQL注入防范 Hibernate是目前使用最多的ORM框架，在Java Web开发中，很多时候不直接使用JDBC，而使用Hibernate来提高开发效率。
在Hibernate中，仍然不应该通过拼接HQL的方式，而应使用参数化的方式来防范SQL注入。有两种方式，一种仍然是使用JDBC一样的占位符“?”，但更好的方式是使用Hibernate的命名参数，例如检测用户名和密码是否正确，使用Hibernate可以写成：
String queryStr = “from user where username=:username ”+”password=:password”;
List result = session.createQuery(queryStr).setString("username", username).setString("password", password).list();
⑷ hibernate的setParameter()方法有什么用
setParameter() 方法设置一个样悄喊式表参数。
说明：这个方法为指定启塌野的样衫誉式表参数指定一个值。
语法：：setParameter(namespaceURI,localName,value)
⑸ hibernate 通过session.createCriteria方法进行查询，是否可防止sql注入
不能阻止，hibernate也是替换，它怎么能防止你SQL注入。
如：sql:select * from emp where ename like '%abc%';——hibernate也是组装的sql，替换属性值。
'%abc%':这个是你的某个bean的一个属性，如果改成'%%' or 1=1
这样不是不管你什么条件都把表中所有的记录都检索出来了。
⑹ 开发人员笔试题
开发人员笔试题
开发人员笔试题大家去面试的时候相信都会做过一些。下面是我整理的开发人员笔试题，欢迎大家阅读。
开发人员笔试题一
一、填空禅巧姿题(本大题10小题,每空1分，共20分) 。
1.Java语言的三大特性即是、宽肢、
2.在Java中，char 型采用____unicode_______编码方案,这样，无论是中文字符还是英文字符,都是占用__2___个字节的内存空间。
3. 形式参数指的是方法被__定义____ 时的参数行，实际参数是方法被__调用___ 时所传递进去的变量或值。
4.JSP
对象则是每个客户专用的。
接口 。
6.程序中实现多线程的方法有两种:继承Thread类和实现
接口。
对优先级。
8.面向对象编程的五大设计原则，分别是、 、、
9.通过Ajax，客户端获取的数据主要有两种类型：文本型和 10. Socket通常也称为套接字 ，用于描述 和
二、选择题(本大题 20 小题，每小题2分.共40分)。
1.在JAVA中，如果父类中某些方法不包含任何逻辑，并且需要由子类重写.应该使用( )关键字来声明父类的这些方法:
A) final B) static C) abstract D) void
2.在JAVA中，已定义两个接口B和C,要定义一个实现这两个接口的类，以下语句正确的是( )。
贺绝A) interface A extend B,C B) interface A implements B,C
C) class A implements B,C D) class A implements B, implements C
3.在JAVA接口中可以定义( )。
A) 静态方法 B) 常量 C) 构造方法 D) 抽象方法
4.假设A有构造方法A (int a),则在类A的其他构造方法中调用该构造方法和语句格式应为( )。
A) A(X) B) this.A(x) C) this(x) D) super(x)
5.设 x = 1 ,y = 2 , z = 3, 则表达式 y+=z--/++x 的值是( )。
A) 3 B) 3.5 C) 4 D) 5
6.下列关于继承的说法哪个正确?( )。
A)子类只继承父类public方法和属性:
B)子类继承父类的非私有属性和方法:
C)子类继承父类的方法，而不继承父类的属性:
D) 子类将继承的所有的属性和方法.
7.在java中.在使用JDBC时。对于多次调用同一条SQL语句的情况, 使用( )通常会提高效。
A) Statement B) CallableStatement
C) PreparedStatement D) PrarmeterStatement
8.下列不能控制一个Servlet的生命周期方的法是：
A) service B) destroy C) doPost D) init
9.能够给一个byte型变量赋值的范围是( )。
A) 0～65535 B) (-128)～127
C)(-32, 768)～32, 767 D) (-256)～255
10.java语言中int类型数据占用多少位?( )。
A) 32 B) 64 C) 16 D) 20
11. ServletContext对象是如何创建的?( )。
A) 由 Servlet容器创建，对于每个HTTP请求.Servlet容器都会创建 一个ServletContext对象
B)由JavaWeb 应用本身为自己创建一个ServletContext对象
C)由Servlet容器创建，对于每个JaveWeb应用，在启动时，Servlet容器都会创建一个ServletContext对象
12.在JSP中不能在不同用户之间共享数据的方法是( )。
A) 通过cookie B) 利用文件系统
C) 利用数据库 D) 通过ServletContext对象
13.以下哪个不是Collection的子接口?( )。
A) List B) Set C) Map D) SortedSet
14. 下面正确的创建 Socket 的语句是( )。
A) Socket a = new Soeket(80):
B) Socket b = new Socket("130. 3. 4. 5", 80):
C) ServerSocket c = new Socket(80)
D) ServerSocket d = new Socket ("130. 3. 4, 5", 80)
15.下面的说法正确的是( )。
A)带有页作用域的对象在一个web应用程序的每个JSP中都存在.
B)指令指定与一个特定的JSP 请求不相关的全局信息。
C)当JSP容器遇到开始定制标签和结束定制标签时，分别调用 doInitBody方法和doAfterBody方法。
D) 动作只在翻译时处理一次。
16.为了区分重载多态中同名的不同方法,要求:( )。
A)参数名不同 B) 采用不同的形式参数列表
C)返回值类型不同 D) 选项A, B, C都对
17.下面是有关子类调用父类构造函数的描述正确的是:( )。
A)子类定义了自己的构造函数.就不会调用父类的构造函数
B)子类必须通过Super关键字调用父类有参数的构造函数
C)如果子类的构造没有通过super调用父类构造函数，那么子类会 先调用子类自己的构造函数，再调用父类不含参数的构造函数。
D)创建子类的对象时，先调用子类自己的构造函数，然后调用父 类的构造函数
18.在Java中，负责对字节代码解释执行的是( )。
A) 垃圾回收器 B) 虚拟机 C) 编译器 D) 多线程机制
19.一个java程序运行从上到下的环境次序是( )。
A) 操作系统、Java程序、jre/jvm、硬件
B) jre/jvm、Java程序、硬件、操作系统
C) java程序、jre/jvm、操作系统、硬件
D) java程序、操作系统、jre/jvm、硬件
20.对于从Employee表中选择记录的'以下代码片段，识别其遗漏的代码行。( ) Connection con = null:
Class. forName("sun.jdbc.odbc.JdbcOdbcDriver"):
con=DriverManager.getConnection("jdbc:odbc:ss" , "sa" , "");
ResultSet rs=stat.executeQuery("select * from Employee");
A) Statement stat=createStatement();
B) Statement stat=con.createStatement ();
C) PreparedStatement stat=con.createStatement():
D) PreparedStatement stat=createPreparedStatement();
三、问答题(本大题6小题，共40分)。
1.请说出 ArrayList , Vector , LinkedList 的存储性能和特性。(6分)
2.什么是单例模式(Singleton) ? 请在下面写出一个单例模式类，并支持多线程调用。(6分)
3.请描述一下JVM加载class文件的原理机制?(6分)
4.请谈谈对SQL注入的理解，请给出你知道的防止SQL注入的方法。(6分)
5.请谈谈对hibernate的理解,并简要叙述Hibernate的一级缓存和二级缓存(8分)。
6.请写出你知道的排序方法，并使用Java语言写出其中一种。(8分)
三、简答题(参考答案)
1. ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法(线程安全)，通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
2. 创建某类对象时，无论创建多少次该类对象只有一份在内存中，这就是单例模式。支持多线程调用，考虑线程安全，只需要加锁即可。
public class Singleton{
private static Singleton instance = null;
private Singleton(){}
private static synchronized void syncInit(){
if(instance == null){
instance = new Singleton();
}
}
public static Singleton getInstance(){
if(instance == null){
syncInit();
}
return instance;
}
}
3. JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。
4.解决办法：a. 利用JavaScript，在客户端进行校验。
b.程序判断 c.使用PreparedStatement连接数据库。(参数化) d.利用框架技术
5. Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用。
一级缓存就是Session级别的缓存，一个Session做了一个查询操作，它会把这个操作的结果放在一级缓存中，如果短时间内这个
session(一定要同一个session)又做了同一个操作，那么hibernate直接从一级缓存中拿，而不会再去连数据库，取数据;
二级缓存就是SessionFactory级别的缓存，顾名思义，就是查询的时候会把查询结果缓存到二级缓存中，如果同一个sessionFactory
创建的某个session执行了相同的操作，hibernate就会从二级缓存中拿结果，而不会再去连接数据库;
6.插入排序、希尔排序、冒泡排序、快速排序、直接排序、归并排序 下面以快速排序为例：
public class quickSort {
inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
public quickSort(){
quick(a);
for(int i=0;i
System.out.println(a[i]);
}
}
public int getMiddle(int[] list, int low, int high) {
int tmp =list[low]; //数组的第一个作为中轴
while (low < high){
while (low < high&& list[high] >= tmp) {
high--;
}
list[low] =list[high]; //比中轴小的记录移到低端
while (low < high&& list[low] <= tmp) {
low++;
. }
list[high] =list[low]; //比中轴大的记录移到高端
}
list[low] = tmp; //中轴记录到尾
return low; //返回中轴的位置
}
public void _quickSort(int[] list, int low, int high) {
if (low < high){
int middle =getMiddle(list, low, high); //将list 数组进行一分为二
_quickSort(list, low, middle - 1); //对低字表进行递归排序
_quickSort(list,middle + 1, high); //对高字表进行递归排序
}
}
public void quick(int[] a2) {
if (a2.length > 0) { //查看数组是否为空
_quickSort(a2,0, a2.length - 1);
}
}
}
开发人员笔试题二
1、简述 private、 protected、 public、 internal 修饰符的访问权限。
2、列举ASP.NET 页面之间传递值的几种方式。
5、如果在一个B/S结构的系统中需要传递变量值，但是又不能使用Session、
Cookie、Application，您有几种方法进行处理?
6、什么是装箱和拆箱?
8、ASP.net的身份验证方式有哪些?分别是什么原理?
9、在C#中，string str = null 与 string str = “” 请尽量使用文字或图
象说明其中的区别。
10、SQLSERVER服务器中，给定表 table1 中有两个字段 ID、LastUpdateDate，
ID表示更新的事务号， LastUpdateDate表示更新时的服务器时间，请使用一句 SQL语句获得最后更新的事务号
11、写出一条Sql语句：取出表A中第31到第40记录(SQLServer,以自动增长的ID作为主键,注意：ID可能不是连续的。
12、能用foreach遍历访问的对象需要实现 ________________接口或声明
________________方法的类型。
14、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可
继承实体类(concrete class)?
15、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
16、如何处理几十万条并发数据?
17、Session有什么重大BUG，微软提出了什么方法加以解决?
18、向服务器发送请求有几种方式?
19、DataReader与Dataset有什么区别?
20、需要实现对一个字符串的处理,首先将该字符串首尾的空格去掉,如果字符串中
间还有连续空格的话,仅保留一个空格,即允许字符串中间有多个空格,但连续的空 格数不可超过一个.
21、什么叫做SQL注入，如何防止?请举例说明。
22、ADO.net中常用的对象有哪些?分别描述一下。
23、什么是SOAP,有哪些应用?
25、float f=-123.567F; int i=(int)f;i的值现在是_____?
26、使用过那几种框架?数据持久层框架，业务层框架。
⑺ SQL注入怎么防范
SQL注入攻击的危害很大，而且防火墙很难对攻击行为进行拦截，主要的SQL注入攻击防范方法，具体有以下几个方面：
1、分级管理
对用户进行分级管理，严格控制用户的权限，对于普通用户，禁止给予数据库建立、删除、修改等相关权限，只有系统管理员才具有增、删、改、查的权限。
2、参数传值
程序员在书写SQL语言时，禁止将变量直接写入到SQL语句，必须通过设置相应的参数来传递相关的变量。从而抑制SQL注入。数据输入不能直接嵌入到查询语句中。同时要过滤输入的内容，过滤掉不安全的输入数据。或者采用参数传值的方式传递输入变量，这样可以最大程度防范SQL注入攻击。
3、基础过滤与二次过滤
SQL注入攻击前，入侵者通过修改参数提交and等特殊字符，判断是否存在漏洞，然后通过select、update等各种字符编写SQL注入语句。因此防范SQL注入要对用户输入进行检查，确保数据输入的安全性，在具体检查输入或提交的变量时，对于单引号、双引号、冒号等字符进行转换或者过滤，从而有效防止SQL注入。
当然危险字符有很多，在获取用户输入提交参数时，首先要进行基础过滤，然后根据程序的功能及用户输入的可能性进行二次过滤，以确保系统的安全性。
4、使用安全参数
SQL数据库为了有效抑制SQL注入攻击的影响。在进行SQLServer数据库设计时设置了专门的SQL安全参数。在程序编写时应尽量使用安全参数来杜绝注入式攻击，从而确保系统的安全性。
5、漏洞扫描
为了更有效地防范SQL注入攻击，作为系统管理除了设置有效的防范措施，更应该及时发现系统存在SQL攻击安全漏洞。系统管理员可以采购一些SQL漏洞扫描工具，通过专业的扫描工具，可以及时的扫描到系统存在的相应漏洞。
6、多层验证
现在的网站系统功能越来越庞大复杂。为确保系统的安全，访问者的数据输入必须经过严格的验证才能进入系统，验证没通过的输入直接被拒绝访问数据库，并且向上层系统发出错误提示信息。同时在客户端访问程序中验证访问者的相关输入信息，从而更有效的防止简单的SQL注入。但是如果多层验证中的下层如果验证数据通过，那么绕过客户端的攻击者就能够随意访问系统。因此在进行多层验证时，要每个层次相互配合，只有在客户端和系统端都进行有效的验证防护，才能更好地防范SQL注入攻击。
7、数据库信息加密
传统的加解密方法大致分为三种：对称加密、非对称加密、不可逆加密。
⑻ 存储过程如何使用
问题一：SQL 中存储过程怎么使用? sql存储过程及应用
一、简介：
存储过程（Stored Procere）， 是一组为了完成特定功能的SQL 语句，集经编译后
存储在数据库中，用户通过指定存储过程的名字并给出参数，如果该存储过程带有参数来执行
它，
在SQL Server 的系列版本中，存储过程分为两类：系统提供的存储过程和用户自定义存储过程
。
系统SP，主要存储master 数据库中，并以sp_为前缀并且系统存储过程主要是从系统表中获取
信息，从而为系统管理员管理SQL Server。用户自定义存储过程是由用户创建，并能完成
某一特定功能，如：查询用户所需数据信息的存储过程。
存储过程具有以下优点
1.存储过程允许标准组件式编程(模块化设计)
存储过程在被创建以后，可以在程序中被多次调用，而不必重新编写该存储过程的SQL语句，而
且数
据库专业人员可随时对存储过程进行修改，但对应用程序源代码毫无影响。因为应用程序源代
码只包含存
储过程的调用语句，从而极大地提高了程序的可移植性。
2.存储过程能够实现快速的执行速度
如果某一操作包含大量的Transaction-SQL 代码,，或分别被多次执行，那么存储过程要比批处理
的
执行速度快很多，因为存储过程是预编译的，在首次运行一个存储过程时，查询优化器对其进
行分析优
化，并给出最终被存在系统表中的执行计划，而批处理的Transaction-SQL 语句在每次运行时
都要进行
编译和优化，因此速度相对要慢一些。
3.存储过程能够减少网络流量
对于同一个针对数据数据库对象的操作，如查询修改，如果这一操作所涉及到的Transaction-SQL
语句被组织成一存储过程，那么当在客户计算机上调用该存储过程时，网络中传送的只是该调
用语句，否
则将是多条SQL 语句从而大大增加了网络流量降低网络负载。
4.存储过程可被作为一种安全机制来充分利用
系统管理员通过，对执行某一存储过程的权限进行限制，从而能够实现对相应的数据访问权限的
限
制。
二、变量
@I
三、流程控制语句(if else | select case | while )
Select ... CASE 实例
DECLARE @iRet INT, @PKDisp VARCHAR(20)
SET @iRet = '1'
Select @iRet =
CASE
WHEN @PKDisp = '一' THEN 1
WHEN @PKDisp = '二' THEN 2
WHEN @PKDisp = '三' THEN 3
WHEN @PKDisp = '四' THEN 4
WHEN @PKDisp = '五' THEN 5
ELSE 100
END
四、存储过程格式
创建存储过程
Create Proc dbo.存储过程名
存储过程参数
AS
执行语句
RETURN
执行存储过程
GO
*********************************************************/
-- 变量的声明,sql里面声明变量时必须在变量前加@符号
DECLARE @I INT
-- 变量的赋值，变量赋值时变量前必须加set
SET @I = 30
-- 声明多个变量
DECLARE @s varchar(10),@a INT
-- Sql 里if语句
IF 条件 BEGIN
执行语句
END
ELSE BEGIN
......>>
问题二：为什么要使用存储过程？ 几个去 IBM 面试的兄弟回来抱怨：去了好几个不同的 IBM项目组，几乎每个面试官问到数据库的时候都要问用没用过存储过程，烦人不？大家去面的程序员，又不是笔者认为，存储过程说白了就是一堆 SQL 的合并。中间加了点逻辑控制。但是存储过程处理比较复杂的业务时比较实用。比如说，一个复杂的数据操作。如果你在前台处理的话。可能会涉及到多次数据库连接。但如果你用存储过程的话。就只有一次。从响应时间上来说有优势。也就是说存储过程可以给我们带来运行效率提高的好处。另外，程序容易出现 BUG数据量小的，或者和钱没关系的项目不用存储过程也可以正常运作。mysql 的存储过程还有待实际测试。如果是正式项目，建议你用 sqlserver 或 oracle的存储过程。数据与数据之间打交道的话，过程会比程序来的快的多。面试官问有没有用存储，实际上就是想知道前来面试的程序员到底做过数据量大的项目没。如果是培训出来的，或者小项目小公司出来的，对存储肯定接触的少了。所以，要想进大公司，没有丰富存储过程经验，是不行的。错。存储过程不仅仅适用于大型项目，对于中小型项目，使用存储过程也是非常有必要的。其威力和优势主要体现在：1.存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般 SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度。2.当对数据库进行复杂操作时(如对多个表进行Update,Insert,Query,Delete时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。这些操作，如果用程序来完成，就变成了一条条的 SQL语句，可能要多次连接数据库。而换成存储，只需要连接一次数据库就可以了。3.存储过程可以重复使用,可减少数据库开发人员的工作量。4.安全性高,可设定只有某此用户才具有对指定存储过程的使用权。存储过程的缺点1：调试麻烦，但是用 PL/SQL Developer 调试很方便！弥补这个缺点。 2：移植问题，数据库端代码当然是与数据库相关的。但是如果是做工程型项目，基本不存在移植问题。 3：重新编译问题，因为后端代码是运行前编译的，如果带有引用关系的对象发生改变时，受影响的存储过程、包将需要重新编译（不过也可以设置成运行时刻自动编译）。4：如果在一个程序系统中大量的使用存储过程，到程序交付使用的时候随着用户需求的增加会导致数据结构的变化，接着就是系统的相关问题了，最后如果用户想维护该系统可以说是很难很难、而且代价是空前的。维护起来更加麻烦！
问题三：oracle中的存储过程,有什么作用，以及怎么在代码中使用？ 楼上也不知道从哪扒下来的，一看LZ就是初学，举点例子不行吗？
比如建立个测试表
create table test(id int,name varchar2(10),counts int); insert into test values (1,'张三',100);insert into test values (2,'李四',200); mit;
现在给你出个题目是
查询所有人加在一起的counts是多少
创建存储过程
create or replace p_test --创建存储过程，asv_counts int;--定义变量begin --开始select sum(counts) into v_counts from test;--将得到的结果放到变量里DBMS_OUTPUT.PUT_LINE(v_counts);--将结果打印输出end;--结束
执行这种不带输入参数的
begin p_test;end;
然后你检查下结果
再给你创建一个带输入参数的
题目是，查询id为1的人名是什么
create or replace p_test1(v_id int)asv_name varchar2(10);beginselect name into v_name from test where id=v_id;DBMS_OUTPUT.PUT_LINE(v_name);end;
执行时这样
beginp_test1(1);end;
第2个我没给你写注释，你看你自己应该能理解吧
补充一下，存储过程不一定只是执行查询，也可以做删除或者修改等sql语句，总体来说就是几个或N个sql语句的 *** ，来完成系统内某些特定的需求，这些需求可以是一个sql搞定的，也可以是多个sql组合的
问题四：SQL 存储过程建立和使用方法? Sql Server的存储过程是一个被命名的存储在服务器上的Transacation-Sql语句 *** ,是封装重复性工作的一种方法,它支持用户声明的变量、条件执行和其他强大的编程功能。 存储过程相对于其他的数据库访问方法有以下的优点： （1）重复使用。存储过程可以重复使用，从而可以减少数据库开发人员的工作量。 （2）提高性能。存储过程在创建的时候就进行了编译，将来使用的时候不用再重新编译。一般的SQL语句每执行一次就需要编译一次，所以使用存储过程提高了效率。 （3）减少网络流量。存储过程位于服务器上，调用的时候只需要传递存储过程的名称以及参数就可以了，因此降低了网络传输的数据量。 （4）安全性。参数化的存储过程可以防止SQL注入式的攻击，而且可以将Grant、Deny以及Revoke权限应用于存储过程。 存储过程一共分为了三类：用户定义的存储过程、扩展存储过程以及系统存储过程。 其中，用户定义的存储过程又分为Transaction-SQL和CLR两种类型。 Transaction-SQL 存储过程是指保存的Transaction-SQL语句 *** ，可以接受和返回用户提供的参数。 CLR存储过程是指对.Net Framework公共语言运行时(CLR)方法的引用，可以接受和返回用户提供的参数。他们在.Net Framework程序集中是作为类的公共静态方法实现的。（本文就不作介绍了） 创建存储过程的语句如下：Code
CREATE { PROC | PROCEDURE } [schema_name.] procere_name [ ; number ]
[ { @parameter [ type_schema_name. ] data_type }
[ VARYING ] [ = default ] [ [ OUT [ PUT ]
] [ ,n ]
[ WITH [ ,n ]
[ FOR REPLICATION ]
AS { [;][ n ] | }
[;]
::=
[ ENCRYPTION ]
[ REPILE ]
[ EXECUTE_AS_Clause ]
::=
{ [ BEGIN ] statements [ END ] }
::=
EXTERNAL NAME assembly_name.class_name.method_name [schema_name]: 代表的是存储过程所属的架构的名称 例如： Create Schema yangyang8848
Go
Create Proc yangyang8848.AllGoods
As Select * From Master_Goods
Go 执行：Exec AllGoods 发生错误。 执......>>
问题五：数据库中的存储过程怎么用 啊！！求解..... 10分 关键字：procere
例子：
SQL> create [or replace] procere procere_name is
begin
--开始执行
insert into test('10001','Visket');
end;
/
以上操作就能为test表添加一条信息
执行存储过程procere用的命令是exec
记住存储过程中，语句结尾一定要有分号
问题六：存储过程是多用还是少用？ 做项目的时候我们有时候会面临一个选择，我们到底是应该多写存储过程还是少写存储过程了？这个问题的争论也是由来已久，在不同的公司以及不同的技术负责人那里往往会得到不同的答案。在实际项目中我们最后所采取的方式，往往不外乎以下三种方式。
第一种方式是要求所有数据库操作不使用任何的存储过程，所有操作都采用标准sql语句来完成，即便是一个动作需要完成多步数据库操作，也不使用任何存储过程，而是在程序代码中采用事务的方式来完成；第二种方式就是就要求所有的数据库操作都用存储过程封装起来，哪怕是一个最简单的insert 操作。在程序代码看不到一行 sql语句，如果采用分工合作的方式，程序员甚至都可以不懂sql语法。第三种方式是一般相对简单的数据库操作采用标准sql语句来完成，一些相对比较复杂的商务逻辑用存储过程来完成。
当然系统如果采用了hibernate或nhibernate之类的框架，不需要写sql语句的时候，我想还是应该属于第三种方式，因为在开发的时候hibernate框架允许我们在适当的时候，抛开其框架自己写存储过程和sql语句来完成数据库操作。其实这三种方式都各有所长，也各有不足。
第一种方式是所有的数据库操作都采用标准sql语句来完成的方式，在程序的执行效率上是肯定不如后面两种方式，系统如果是一个大型的ERP，这种方式就是绝对不可取的。因为在开发基本结束后，系统如果需要优化或者希望得到优化时，那对开发人员来说就是一件非常麻烦的事情了，因为优化的重点基本上都是集中数据库操作上，开发人员所能做的就是一个个sql语句去检查，是不是还能进一步优化，尤其是一些相对比较复杂的查询语句是我们所检查的重点。分页显示就是一个典型的存储过程提高程序效率的例子。如果使用存储过程来进行分页操作，就是利用存储过程从系统中提取我们所需要的记录集，分页的效率就大大提高了。反过来如果我们不用存储过程进行分页操作，是利用sql语句的方式把所有记录集都读入内存中，然后再从内存中获取我们所需要的记录 *** ，这样分页效率自然就降低了。当然利用sql语句也能得到我们所需要的记录，而不是所有记录，但是那样麻烦多了，不在我们讨论范围之内。
这种方式另外还有一个不足之处，一个系统或一个项目总会或多或少地存在有一些容易变化而又复杂的商务逻辑，如果把这些复杂的商务逻辑封装到存储过程中，商务逻辑的变化都只涉及存储过程变化，而与程序代码不 *** ，那么不用存储过程太可惜了。
这种方式虽然有不足，但是一旦采用这种方式的话，我们如果对该项目进行数据库移植的时候，开发人员就会觉得当时的决策人是多么的伟大与英明。而且我们知道access和mysql的以前版本是不提供存储过程支持的，所有一些中小项目在这个方面的选择往往也是不得已而为之。不用存储过程有一个优点，调试代码的时候没有存储过程可是要方便很多很多的哦，所以在很多很多的项目中都是采用标准的sql语句而不使用任何的存储过程。这可是大多程序员用标准sql而不用存储过程的直接原因，说白了，就是嫌麻烦。
第二种方式是所有的数据库操作全部采用存储过程封装的方式，如果采用这种方式，程序的执行效率相对要高，尤其面对在一些复杂的商务逻辑时候，不仅在效率方面有明显的提高，而且当商务逻辑发生变化时，我们开发人员做相应的修改的时候，往往都不用修改程序代码，仅仅修改存储过程就能满足系统变化了。
还有一个好处就是当我们开发好的一个系统后，如果发现一种模式或语言在某些方面难以满足需求时，我们就可以很快的用两外一种语言来重新开发，那个时候就非常方便了。比如在02年中科院下属的一个公司就用ASP开......>>
问题七：在SQL中存储过程的一般语法是什么？ sql server存储过程语法
存储过程就是作为可执行对象存放在数据库中的一个或多个SQL命令。
定义总是很抽象。存储过程其实就是能完成一定操作的一组SQL语句，只不过这组语句是放在数据库中的(这里我们只谈SQL Server)。如果我们通过创建存储过程以及在ASP中调用存储过程，就可以避免将SQL语句同ASP代码混杂在一起。这样做的好处至少有三个：
第一、大大提高效率。存储过程本身的执行速度非常快，而且，调用存储过程可以大大减少同数据库的交互次数。
第二、提高安全性。假如将SQL语句混合在ASP代码中，一旦代码失密，同时也就意味着库结构失密。
第三、有利于SQL语句的重用。
在ASP中，一般通过mand对象调用存储过程，根据不同情况，本文也介绍其它调用方法。为了方便说明，根据存储过程的输入输出，作以下简单分类：
1. 只返回单一记录集的存储过程
假设有以下存储过程(本文的目的不在于讲述T-SQL语法，所以存储过程只给出代码，不作说明)：
/*SP1*/
CREATE PROCEDURE dbo.getUserList
as
set nocount on
begin
select * from dbo.[userinfo]
end
go
以上存储过程取得userinfo表中的所有记录，返回一个记录集。通过mand对象调用该存储过程的ASP代码如下:
'**通过mand对象调用存储过程**
DIM Mym,MyRst
Set Mym = Server.CreateObject(ADODB.mand)
Mym.ActiveConnection = MyConStr 'MyConStr是数据库连接字串
Mym.mandText = getUserList '指定存储过程名
Mym.mandType = 4 '表明这是一个存储过程
Mym.Prepared = true '要求将SQL命令先行编译
Set MyRst = Mym.Execute
Set Mym = Nothing
存储哗程取得的记录集赋给MyRst，接下来，可以对MyRst进行操作。
在以上代码中，mandType属性表明请求的类型，取值及说明如下：
-1 表明mandText参数的类型无法确定
1 表明mandText是一般的命令类型
2 表明mandText参数是一个存在的表名称
4 表明mandText参数是一个存储过程的名称
还可以通过Connection对象或Recordset对象调用存储过程，方法分别如下：
'**通过Connection对象调用存储过程**
DIM MyConn,MyRst
Set MyConn = Server.CreateObject(&qu......>>
问题八：如何使用Oracle存储过程的一个简单例子 楼主您好
---创建表
create table TESTTABLE
(
id1 VARCHAR2(12),
name VARCHAR2(32)
)
select t.id1,t.name from TESTTABLE t
insert into TESTTABLE (ID1, NAME)
values ('1', 'zhangsan');
insert into TESTTABLE (ID1, NAME)
values ('2', 'lisi');
insert into TESTTABLE (ID1, NAME)
values ('3', 'wangwu');
insert into TESTTABLE (ID1, NAME)
values ('4', 'xiaoliu');
insert into TESTTABLE (ID1, NAME)
values ('5', 'laowu');
---创建存储过程
create or replace procere test_count
as
v_total number(1);
begin
select count(*) into v_total from TESTTABLE;
DBMS_OUTPUT.put_line('总人数：'||v_total);
end;
--准备
--线对scott解锁：alter user scott account unlock;
--应为存储过程是在scott用户下。还要给scott赋予密码
---alter user scott identified by tiger;
---去命令下执行
EXECUTE test_count;
----在ql/spl中的sql中执行
begin
-- Call the procere
test_count;
end;
create or replace procere TEST_LIST
AS
---是用游标
CURSOR test_cursor IS select t.id1,t.name from TESTTABLE t;
begin
for Test_record IN test_cursor loop---遍历游标，在打印出来
DBMS_OUTPUT.put_line(Test_record.id1||Test_record.name);
END LOOP;
test_count;--同时执行另外一个存储过程（TEST_LIST中包含存储过程test_count）
end;
-----执行存储过程TEST_LIST
begin
TEST_LIST;
END;
---存储过程的参数
---IN 定义一个输入参数变量，用于传递参数给存储过程
--OUT 定义一个输出参数变量，用于从存储过程获取数据
---IN OUT 定义一个输入、输出参数变量，兼有以上两者的功能
......>>
问题九：如何使用sql语句查看存储过程 --下面这条语句可以查看存储过程具体代码exec sp_helptext 存储过程名--下面这条语句查看数据库中有哪些存储过程select * from sysobjects where type='P'
问题十：存储过程中怎么使用row 一般分为十种情况，每种语法各不相同： 1、 创建语法create proc | procere pro_name [{@参数数据类型} [=默认值] [output], {@参数数据类型} [=默认值] [output], .... ]as SQL_statements2、 创建不带参数存储过程--创建存储过程if (exists (select * from sys.objects where name = 'proc_get_student')) drop proc proc_get_studentgocreate proc proc_get_studentas select * from student;--调用、执行存储过程exec proc_get_student;3、 修改存储过程--修改存储过程alter proc proc_get_studentasselect * from student;4、 带参存储过程--带参存储过程if (object_id('proc_find_stu', 'P') is not null) drop proc proc_find_stugocreate proc proc_find_stu(@startId int, @endId int)as select * from student where id between @startId and @endIdgoexec proc_find_stu 2, 4;5、 带通配符参数存储过程--带通配符参数存储过程if (object_id('proc_findStudentByName', 'P') is not null) drop proc proc_findStudentByNamegocreate proc proc_findStudentByName(@name varchar(20) = '%j%', @nextName varchar(20) = '%')as select * from student where name like @name and name like @nextName;goexec proc_findStudentByName;exec proc_findStudentByName '%o%', 't%';6、 带输出参数存储过程if (object_id('proc_getStudentRecord', 'P') is not null) drop proc proc_getStudentRecordgocreate proc proc_getStudentRecord( @id int, --默认输入参数 @name varchar(20) out, --输出参数 @age varchar(20) output--输入输出参数)as select @name = name, @age = age from student where id = @id and sex = @age;go-- declare @id int, @name varchar(20), @temp varchar(20)......>>
⑼ Hibernate中CriteriaQuery可以使用原生sql作为排序条件么
Hibernate对原生SQL查询的支持和控制是通过SQLQuery接口亏唤芹实现的，这种销毕方式弥补了HQL、Criterion查询的不足，在操作和使用上往往更加的自由和灵活，如果使用得当，数据库操作的效率还会得到不同程度的提升。
Hibernate对原生
SQL查询的支持和控制是通过SQLQuery接口实现的。通过Session接口，我们能够很方便的创建一个SQLQuery(SQLQuery是一个接口，在Hibernate4.2.2之前，默认返回的是SQLQuery的实现类——SQLQueryImpl对象，在下文中出现的SQLQuery如非注明，都是指该子类)对象来进行原生SQL查询：
session.createSQLQuery(String sql);
SQLQuery实现了Query接口，因此你可以使用Query接口中提供的API来获取数据。
最简单的示例
//获取所有查询结果
session.createSQLQuery("select * from note").list();
//仅获取第一条结果
session.createSQLQuery("select * from note where id = 1").uniqueResult();
使用预处理SQL
预处理SQL的好处自然不必多说，除了众所周知的能够防止SQL注入攻击外，还能够在一定程度上提高SQL的查询效率。SQLQuery提供了众多的接口来分别设置不同类型的参数，诸如setBigDecimal、setBinary、setDouble等，详参SQLQuery的JavaDoc，此处不再赘述。这里仅重点说一下通用的SQL参数设置接口setParameter。
如下代码示范了如何使用SQLQuery执行预处理SQL：
SQLQuery query = session.createSQLQuery("select * from note where id = ?");
//设置第一个参数的值为12,即查询ID=12的note
query.setParameter(0, 12);
List list = query.list();
...
这里需要注明一点，无论是通过不同类型参数的设置接口来设置SQL参数，还是通过setParameter来设置参数，下标都是从0开始的，而不是从1开始的！
使用自定义的结果转换器处理查询结果
SQLQuery
接口预留了setResultTransformer接口以实现使用用户自定义的ResultTransformer结果集转换器处理查询结果。
ResultTransformer接口非常简单，只有两个方法，分别用来转换单行数据和所有结果数据。经过自定义ResultTransformer生成的实体，并未加入Session，因此是非受管实体。
如下代码，示范了如何将单行数据装入LinkedHashMap对象中:
query.setResultTransformer(new ResultTransformer() {
@Override
public Object transformTuple(Object[] values, String[] columns) {
Map<String, Object> map = new LinkedHashMap<String, Object>(1);
int i = 0;
for(String column : columns){
map.put(column, values[i++]);
}
return map;
}
@Override
public List transformList(List list) {
return list;
}
});
如果不设置自定义的ResultTransformer转换器，则Hibernate将每行返回结果的数据按照结果列的顺序装入Object数组中。
这里介绍一个工具类：Transformers，它提供了一些常用的转换器，能够帮助我们快速转换结果集，如Transformers.aliasToBean(Note.class)能够将查询结果依别名注入到Note实体中。
使用标量
使用链冲SQLQuery执行原生SQL时，Hibernate会使用ResultSetMetadata来判定返回的标量值的实际顺序和类型。如果要避免过多的使用ResultSetMetadata,或者只是为了更加明确的指名返回值，可以使用addScalar()。
session.createSQLQuery("select * from note where id = 1")
.addScalar("id", LongType.INSTANCE)
.addScalar("name", StringType.INSTANCE)
.addScalar("createtime", DateType.INSTANCE);
这个查询指定了SQL查询字符串,要返回的字段和类型.它仍然会返回Object数组,但是此时不再使用ResultSetMetdata,而是明确的将id,name和
createtime按照Long,
String和Date类型从resultset中取出。同时，也指明了就算query是使用*来查询的，可能获得超过列出的这三个字段，也仅仅会返回这三个字段。
对全部或者部分的标量值不设置类型信息也是可以的：
session.createSQLQuery("select * from note where id = 1")
.addScalar("id")
.addScalar("name")
.addScalar("createtime", DateType.INSTANCE);
没有被指定类型的字段将仍然使用ResultSetMetdata获取其类型。注意，字段不区分大小写，同时不能够指定不存在的字段！
关于从ResultSetMetaData返回的java.sql.Types是如何映射到Hibernate类型，是由方言(Dialect)控制的。假若某个指定的类型没有被映射，或者不是你所预期的类型，你可以通过Dialet的registerHibernateType调用自行定义。
如果仅指定了一个scalar，那么...
Date createTime = (Date)session.createSQLQuery("select * from note where id = 1")
.addScalar("createtime", DateType.INSTANCE)
.uniqueResult();
如果我们的SQL语句使用了聚合函数，如count、max、min、avg等，且返回结果仅一个字段，那么Hibernate提供的这种提取标量结果的方式就非常便捷了。
实体查询
上面的查询都是返回标量值的，也就是从resultset中返回的“裸”数据。下面展示如何通过addEntity()让原生查询返回实体对象。
session.createSQLQuery("select * from note where id = 1").addEntity(Note.class);
session.createSQLQuery("select id,name,createtime from note where id = 1").addEntity(Note.class);
这个查询指定SQL查询字符串,要返回的实体。假设Note被映射为拥有id,name和createtime三个字段的类，以上的两个查询都返回一个List，每个元素都是一个Note实体。
假若实体在映射时有一个many-to-one的关联指向另外一个实体，在查询时必须也返回那个实体，否则会导致发生一个"column
not found"的数据库错误。这些附加的字段可以使用*标注来自动返回，但我们希望还是明确指明，看下面这个具有指向Dog的many-to-one的例子：
session.createSQLQuery("select id,note,createtime,author from note where id = ?").addEntity(Note.class);
author字段即为Note实体和Author实体的关联字段，只需在查询时得到该字段的值，Hibernate即可使用该值找到对应的关联实体。如上例中，note.getAuthor()即可返回当前Note所属的Author对象。
处理关联和集合类
通过提前抓取将Author连接获得，而避免初始化proxy带来的额外开销也是可能的。这是通过addJoin()方法进行的，这个方法可以让你将关联或集合连接进来。
session.createSQLQuery("select {note.*}, {author.*} from note note, user author where note.author = author.id")
.addEntity("note", Note.class)
.addJoin("author", "note.author");
上面的例子是多对一的关联查询，反过来做一对多的关联查询也是可以的。如下的例子中，author.notes表示该用户发表的所有日记(Note)，Set集合类型：
session.createSQLQuery("select {author.*},{note.*} from note note, user author where author.id = ? and note.author = author.id")
.addEntity("author", User.class)
.addJoin("note", "author.notes");
注意：join查询会在每行返回多个实体对象，处理时需要注意。
别名和属性引用
假若SQL查询连接了多个表，同一个字段名可能在多个表中出现多次，这会导致SQL错误。不过在我们可以通过使用占位符来完美地解决这一问题。
其实在上例中已经用到了占位符：
session.createSQLQuery("select {note.*}, {author.*} from note note, user author where note.author = author.id")
.addEntity("note", Note.class)
.addJoin("author", "note.author");
这个查询指明SQL查询语句，其中包含占位附来让Hibernate注入字段别名,查询并返回的实体。
上面使用的{note.*}和{author.*}标记是作为“所有属性”的简写形式出现的，当然你也可以明确地罗列出字段名。但如下的范例代码中我们让Hibernate来为每个属性注入SQL字段别名，字段别名的占位符是表别名
+ . + 属性名。
注意:属性名区分大小写，而且不能够在where子句中使用占位符。
SQLQuery query = session.createSQLQuery("select note.id as {note.id},note as {note.note},createtime as {note.createTime},author as {note.author}, {author.*} from note, user author where note.id = ? and note.author = author.id");
query.addEntity("note", Note.class);
query.addJoin("author", "note.author");
大多数情况下，上面的别名注入方式可以满足需要，但在使用更加复杂的映射，比如复合属性、通过标识符构造继承树，以及集合类等等情况下，则需要更加复杂的别名注入方式。
下表列出了使用别名注射参数的不同方式：
⑽ struts2怎么防止sql注入
sql注入大家都不陌生，是一种常见的攻击方式，攻击者在界面的表单信息或url上输入一些奇怪的sql片段，例如“or ‘1’=’1’”这样的语句，有可能入侵参数校验不足的应用程序。所以在我们的应用中需要做一些工作，来防备这样的攻击方式。在一些安全性很高的应用中，比如银行软件，经常使用将sql语句全部替换为存储过程这样的方式，来防止sql注入，这当然是一种很安全的方式，但我们平时开发中，可能不需要这种死板的方式。
一起jquery,17jquery
mybatis框架作为一款半自动化的持久层框架，其sql语句都要我们自己来手动编写，这个时候当然需要防止sql注入。其实Mybatis的sql是一个具有“输入+输出”功能，类似于函数的结构，如下：
一起jquery,17jquery
<</span>select id="getBlogById" resultType="Blog" parameterType=”int”>
17jquery.com
select id,title,author,content 内容来自17jquery
from blog where id=#{id} 一起jquery,17jquery
</</span>select> 内容来自17jquery
这里，parameterType标示了输入的参数类型，resultType标示了输出的参数类型。回应上文，如果我们想防止sql注入，理所当然地要在输入参数上下功夫。上面代码中高亮部分即输入参数在sql中拼接的部分，传入参数后，打印出执行的sql语句，会看到sql是这样的：
内容来自17jquery
select id,title,author,content from blog where id = ?
一起jquery,17jquery
不管输入什么参数，打印出的sql都是这样的。这是因为mybatis启用了预编译功能，在sql执行前，会先将上面的sql发送给数据库进行编译，执行时，直接使用编译好的sql，替换占位符“？”就可以了。因为sql注入只能对编译过程起作用，所以这样的方式就很好地避免了sql注入的问题。
一起jquery,17jquery
mybatis是如何做到sql预编译的呢？其实在框架底层，是jdbc中的PreparedStatement类在起作用，PreparedStatement是我们很熟悉的Statement的子类，它的对象包含了编译好的sql语句。这种“准备好”的方式不仅能提高安全性，而且在多次执行一个sql时，能够提高效率，原因是sql已编译好，再次执行时无需再编译。 一起jquery,17jquery
话说回来，是否我们使用mybatis就一定可以防止sql注入呢？当然不是，请看下面的代码：
17jquery.com
<</span>select id="orderBlog" resultType="Blog" parameterType=”map”>
17jquery.com
select id,title,author,content 一起jquery,17jquery
from blog order by ${orderParam}
17jquery.com
</</span>select>
内容来自17jquery
仔细观察，内联参数的格式由“#{xxx}”变为了${xxx}。如果我们给参数“orderParam”赋值为”id”,将sql打印出来，是这样的：
内容来自17jquery
select id,title,author,content from blog order by id
一起jquery,17jquery
显然，这样是无法阻止sql注入的。在mybatis中，”${xxx}”这样格式的参数会直接参与sql编译，从而不能避免注入攻击。但涉及到动态表名和列名时，只能使用“${xxx}”这样的参数格式，所以，这样的参数需要我们在代码中手工进行处理来防止注入。 一起jquery,17jquery
结论：在编写mybatis的映射语句时，尽量采用“#{xxx}”这样的格式。若不得不使用“${xxx}”这样的参数，要手工地做好过滤工作，来防止sql注入攻击。