面试题收集

一、tomcat有哪些性能调优方法,请举例说明?

 在线上环境中我们是采用了tomcat作为Web服务器,它的处理性能直接关系到用户体验,在平时的工作和学习中,归纳出以下七种调优经验。

1. 服务器资源

    服务器所能提供CPU、内存、硬盘的性能对处理能力有决定性影响。
    (1) 对于高并发情况下会有大量的运算,那么CPU的速度会直接影响到处理速度。
    (2) 内存在大量数据处理的情况下,将会有较大的内存容量需求,可以用-Xmx -Xms -XX:MaxPermSize等参数对内存不同功能块进行划分。我们之前就遇到过内存分配不足,导致虚拟机一直处于full GC,从而导致处理能力严重下降。
    (3) 硬盘主要问题就是读写性能,当大量文件进行读写时,磁盘极容易成为性能瓶颈。最好的办法还是利用下面提到的缓存。

2. 利用缓存和压缩

    对于静态页面最好是能够缓存起来,这样就不必每次从磁盘上读。这里我们采用了Nginx作为缓存服务器,将图片、css、js文件都进行了缓存,有效的减少了后端tomcat的访问。

    另外,为了能加快网络传输速度,开启gzip压缩也是必不可少的。但考虑到tomcat已经需要处理很多东西了,所以把这个压缩的工作就交给前端的Nginx来完成。可以参考之前写的《利用nginx加速web访问》。

    除了文本可以用gzip压缩,其实很多图片也可以用图像处理工具预先进行压缩,找到一个平衡点可以让画质损失很小而文件可以减小很多。曾经我就见过一个图片从300多kb压缩到几十kb,自己几乎看不出来区别。

3. 采用集群

    单个服务器性能总是有限的,最好的办法自然是实现横向扩展,那么组建tomcat集群是有效提升性能的手段。我们还是采用了Nginx来作为请求分流的服务器,后端多个tomcat共享session来协同工作。可以参考之前写的《利用nginx+tomcat+memcached组建web服务器负载均衡》。

4. 优化tomcat参数

    这里以tomcat7的参数配置为例,需要修改conf/server.xml文件,主要是优化连接配置,关闭客户端dns查询。

  1. <Connector port="8080"   
  2.            protocol="org.apache.coyote.http11.Http11NioProtocol"  
  3.            connectionTimeout="20000"  
  4.            redirectPort="8443"   
  5.            maxThreads="500"   
  6.            minSpareThreads="20"  
  7.            acceptCount="100" 
  8.            disableUploadTimeout="true" 
  9.            enableLookups="false"   
  10.            URIEncoding="UTF-8" /> 

5. 改用APR库

    tomcat默认采用的BIO模型,在几百并发下性能会有很严重的下降。tomcat自带还有NIO的模型,另外也可以调用APR的库来实现操作系统级别控制。

    NIO模型是内置的,调用很方便,只需要将上面配置文件中protocol修改成org.apache.coyote.http11.Http11NioProtocol,重启即可生效。上面配置我已经改过了,默认的是HTTP/1.1。

    APR则需要安装第三方库,在高并发下会让性能有明显提升。具体安装办法可以参考http://www.cnblogs.com/huangjingzhou/articles/2097241.html。安装完成后重启即可生效。如使用默认protocal就是apr,但最好把将protocol修改成org.apache.coyote.http11.Http11AprProtocol,会更加明确

    在官方找到一个表格详细说明了这三种方式的区别:

  1.                   Java Blocking Connector   Java Nio Blocking Connector   APR/native Connector 
  2.                              BIO                         NIO                       APR 
  3. Classname                AjpProtocol               AjpNioProtocol           AjpAprProtocol 
  4. Tomcat Version           3.x onwards                 7.x onwards              5.5.x onwards 
  5. Support Polling              NO                          YES                       YES 
  6. Polling Size                 N/A                   maxConnections             maxConnections 
  7. Read Request Headers      Blocking                  Sim Blocking                   Blocking 
  8. Read Request Body         Blocking                  Sim Blocking                   Blocking 
  9. Write Response            Blocking                  Sim Blocking                   Blocking 
  10. Wait for next Request     Blocking                  Non Blocking               Non Blocking 
  11. Max Connections        maxConnections              maxConnections             maxConnections 

6. 优化网络

    Joel也明确提出了优化网卡驱动可以有效提升性能,这个对于集群环境工作的时候尤为重要。由于我们采用了linux服务器,所以优化内核参数也是一个非常重要的工作。给一个参考的优化参数:

  1. 1. 修改/etc/sysctl.cnf文件,在最后追加如下内容: 
  2.  
  3. net.core.netdev_max_backlog = 32768 
  4. net.core.somaxconn = 32768 
  5. net.core.wmem_default = 8388608 
  6. net.core.rmem_default = 8388608 
  7. net.core.rmem_max = 16777216 
  8. net.core.wmem_max = 16777216 
  9. net.ipv4.ip_local_port_range = 1024 65000 
  10. net.ipv4.route.gc_timeout = 100 
  11. net.ipv4.tcp_fin_timeout = 30 
  12. net.ipv4.tcp_keepalive_time = 1200 
  13. net.ipv4.tcp_timestamps = 0 
  14. net.ipv4.tcp_synack_retries = 2 
  15. net.ipv4.tcp_syn_retries = 2 
  16. net.ipv4.tcp_tw_recycle = 1 
  17. net.ipv4.tcp_tw_reuse = 1 
  18. net.ipv4.tcp_mem = 94500000 915000000 927000000 
  19. net.ipv4.tcp_max_orphans = 3276800 
  20. net.ipv4.tcp_max_syn_backlog = 65536 
  21.  
  22. 2. 保存退出,执行sysctl -p生效 

7. 让测试说话

    优化系统最忌讳的就是只调优不测试,有时不适当的优化反而会让性能更低。以上所有的优化方法都要在本地进行性能测试过后再不断调整参数,这样最终才能达到最佳的优化效果。

 

补充Bio、Nio、Apr模式的测试结果:

    对于这几种模式,我用ab命令模拟1000并发测试10000词,测试结果比较意外,为了确认结果,我每种方式反复测试了10多次,并且在两个服务器上都测试了一遍。结果发现Bio和Nio性能差别非常微弱,难怪默认居然还是Bio。但是采用apr,连接建立的速度会有50%~100%的提升。直接调用操作系统层果然神速啊,这里强烈推荐apr方式!

 

二、Spring中bean的作用域有哪些?

Struts

三、struts2和struts1有哪些区别?

两者对比:

(1)、在Action实现类方面对比:Struts 1要求action类继承一个抽象基类;Strut 1的一个具体问题是使用抽象类编程而不是接口。Struts 2 Action类可以实现一个Action接口,也可以实现其他接口,使可选和定制的服务成为可能。

(2)、线程模式方面对比:Strut 1 Action是单例模式并且必须是线程安全的,因为仅有Action的一个实例来处理所有的请求。Struts 2 Action对象为每一个请求参数一个实例,因此没有线程安全问题。

(3)、Servlet依赖方面的对比:Struts1 Action依赖Servlet ApI,因为在Struts 1 Action的execute方法中有HttpServletRequest和HttpServletResponse参数。Strut2 Action不再依赖Servlet API,从而允许Action脱离Web容器运行,从而降低了测试Action的难度。当然,如果Action需要直接访问HttpServletRequest和HttpServletResponse参数,Struts 2 Action仍然可以访问它们。

(4)、可测性方面对比:Struts 1 Action的一个主要问题是execute方法依赖于Servlet API,这使得Action的测试要依赖于Web容器。为了脱离Web容器测试 Struts 1的Action,必须借助于第三方扩展:Struts TestCase,该扩展下包含了系列的Mock对象(模拟了HttpServletRequest和HttpServletResponse对象),从而可以脱离Web容器测试Struts 1的Action类。

(5)、封装请求参数的对比:Struts 1使用ActionForm对象封装用户的请求参数,所有的ActionForm必须继承一个基类:ActionForm。普通的JavaBean不能用作ActionForm,所有的ActionForm必须继承一个基类ActionForm。

(6)、表达式语言的对比:Struts1整合了JSTL,因此可以使用JSTL语言。Struts2可以使用JSTL,但它整合了一种更强大和灵活的表达式语言:OGNL(Object Graph Notation Language),因此,Struts2下的表达式语言功能更加强大。

(7)、绑定值到视图的对比:Struts 1使用标准JSP机制把对象绑定到视图页面;Struts 2使用“ValueStack”技术,使标签库能够访问值,而不需要把对象和视图页面绑定在一起。

(8)、类型转换对比:Struts 1 ActionForm属性通常是String类型,使用Commons-Beanutils进行类型转换,每个类一个转换器,转换器是不可配置的;Struts2使用OGNL进行类型转换,支持级别数据类型和常用对象之间的转换。

(9)、Action执行控制的对比:Struts1支持每一个模块对应一个请求处理,但是模块中的所有Action必须共享相同的生命周期。Struts2支持通过拦截器堆栈(Interceptor Stacks)为每一个Action创建不同的生命周期。开发这可以根据需要创建相应堆栈,从而和不同的Action一起作用。

struts1的控制器分为核心控制器ActionServlet和业务逻辑控制器Action。控制器是struts1的框架的核心。

struts1的缺点:

     由于它和JSP/Servlet耦合非常紧密,因而导致了许多不可回避的缺陷,随着WEB应用的逐渐扩大,这个缺陷渐变成制约Struts1发展的重要因素--这是struts2出现的重要原因。

1、Struts1只支持JSP作为表现层技术,不提供与其他表现层技术,例如Velocity、FreeMarker等技术的整合。

2、与Servlet API严重耦合,难于测试。在Struts1的业务逻辑控制器内,充满了大量的Servlet API。

3、代码严重依赖于Struts1 API,属于侵入式设计,降低代码复用。

      action必须继承Struts1的Action基类,实现处理方法时,又包含了大量的Struts1 API:如ActionMapping、ActionForm和ActionForward类。这种侵入式设计的最大弱点在于,一旦系统需要重构时,这些Action类将完全没有利用价值,成为一堆废品。

Struts2框架:

Struts 2的控制器也类似的有核心控制器FilterDispatcher和业务控制器Action组成。实际上,Struts 2应用中起作用的业务控制器不是用户定义的Action,而是系统生成的Action代理,但该Action代理以用户定义的Action为目标。在struts 2的业务的action中,比struts1有以下明显优势:

a、Action类完全是一个POJO,因此具有很好的代码复用性;

b、Action类无需与Servlet API耦合,因此进行单元测试非常简单;

c、Action类的execute方法仅返回一个字符串作为处理结果,该处理结果可映射到任何的视图,甚至是另一个Action。

Struts2框架的大致处理流程:

1、浏览器发送请求,如/mypage.action等;

2、核心控制器FilterDispactcher根据请求决定调用合适的Action;FilterDispactcher作为一个Filter运行在Web应用中,它负责拦截所有的用户请求,根据请求的URL中标明的逻辑组件,调用相应的Action来处理用户请求。

3、WebWork的拦截器链自动对请求应用通用功能,如workflow、validation或文件上传功能;

4、回调Action的execute方法,该execute方法先获取用户请求参数,然后执行某种数据库操作,既可以使将数据保存到数据库,也可以从数据库中检索信息。

5、Action的execute方法处理接口信息将被输出到浏览器中,可以使HTML页面、图像,也可以是PDF文档等。此时支持的视图技术非常多,既支持JSP,也支持Velocity、FreeMarker等模板技术。

Struts 2的配置文件:

当Struts2创建系统的Action代理时,需要使用Struct 2的配置文件。

Struts 2的配置文件有两份:

a、配置Action的struts.xml文件;

b、配置Struts 2全局熟悉的struts.properties文件;

      用于配置Struts 2全局属性,如

#指定Struts 2处于开发状态 struts。devMode=false //指定当Struts 2配置文件改变后,web框架是否重新加载Struts 2配置文件 struts.configuration.xml.reload=true

 Struts2拦截器:

    拦截器其实就是AOP(面向切面编程)的编程思想。拦截器机制体现的是一种软件复用的原则。拦截器允许在Action处理之前,或者Action处理结束之后,插入开发者自定义的代码。

拦截器用法:Struts2中的拦截器可以完成如下操作:

a、进行权限控制;

b、跟踪日志(记录每个浏览者所请求的每个Action);

c、跟踪系统的性能瓶颈(我们可以通过记录每个Action开始处理时间和结束处理时间,从而取得耗时较长的Action);

 拦截器原理:类似JDK动态代理做法,在Struts2框架中,将拦截器放在配置文件中配置,而不再需要以硬编码的方式耦合,从而提高了更好的解耦。

拦截器和AOP的关系:拦截器与AOP(Aspect Orient Program,面向切面编程)是密切相关的,AOP从程序运行角度来考虑程序的流程,取得业务处理过程的切面,在特定切面通过系统自动插入特定方法。AOP面向的是程序运行中各个步骤,以一种松耦合方法来组合业务处理的各个步骤。

在AOP编程中有3个重要的概念:

a、目标对象:包含被拦截方法的原始对象;

b、被插入的处理方法:定义拦截器中,会在被拦截方法之前、之后自动执行的方法。

c、代理对象:以目标对象为蓝本,由系统创建的新对象。

 

Struts中DispatchAction和Action类有什么不同?

DispatchAction是Struts包含的另一个能大量节省开发时间的Action类。与其它Action类仅提供单个execute()方法实现单个业务不同,DispatchAction允许你在单个Action类中编写多个与业务相关的方法。这样可以减少Action类的数量,并且把相关的业务方法集合在一起使得维护起来更容易。

要使用DispatchAction的功能,需要自己创建一个类,通过继承抽象的DispatchAction得到。对每个要提供的业务方法必须有特定的方法signature。例如,我们想要提供一个方法来实现对购物车添加商品清单,创建了一个类ShoppingCartDispatchAction提供以下的方法:
public ActionForward addItem(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response){
throws Exception;
}

那么,这个类很可能还需要一个deleteItem()方法从客户的购物车中删除商品清单,还有clearCart()方法清除购物车等等。这时我们就可以把这些方法集合在单个Action类,不用为每个方法都提供一个Action类。

在调用ShoppingCartDispatchAction里的某个方法时,只需在URL中提供方法名作为参数值。就是说,调用addItem()方法的 URL看起来可能类似于:

http://myhost/storefront/action/cart?method=addItem

其中method参数指定ShoppingCartDispatchAction中要调用的方法。参数的名称可以任意配置,这里使用的”method”只是一个例子。参数的名称可以在Struts配置文件中自行设定。

1、              Struts的控制器如何知道什么样的信息转发到什么样的Action类呢?

在struts 中,控制器信息转发的配置映射信息是存储在特定的XML文件(比如struts-config.xml)中的。这些配置信息在系统启动的时候被读入内存,供struts framework在运行期间使用。在内存中,每一个<action>元素都与org.apache.struts.action.ActionMapping类的一个实例对应。当可以通过/logonAction.do(此处假设配置的控制器映射为*.do)提交请求信息的时候,控制器将信息委托com.test.LogonAction处理。调用LogonAction实例的execute()方法。同时将Mapping实例和所对应的LogonForm Bean信息传入。其中name=LogonForm,使用的form-bean元素所声明的ActionForm Bean。

介绍一下Struts的Action类?

ActionServlet把全部提交的请求都被控制器委托到RequestProcessor对象。RequestProcessor使用struts-config.xml文件检查请求URI找到动作Action标示符。
一个Action 类的角色,就像客户请求动作和业务逻辑处理之间的一个适配器(Adaptor),其功能就是将请求与业务逻辑分开。这样的分离,使得客户请求和Action类之间可以有多个点对点的映射。而且Action类通常还提供了其它的辅助功能,比如:认证(authorization)、日志(logging)和数据验证(validation)。
Action最为常用的是execute()方法当Controller收到客户的请求的时候,在将请求转移到一个Action实例时,如果这个实例不存在,控制器会首先创建,然后会调用这个Action实例的execute()方法。Struts Framework为应用系统中的每一个Action类只创建一个实例。因为所有的用户都使用这一个实例,所以你必须确定你的Action 类运行在一个多线程的环境中。

 

介绍一下Struts的ActionServlet类?

ActionServlet继承自javax.servlet.http.HttpServlet类,其在Struts framework中扮演的角色是中心控制器。它提供一个中心位置来处理全部的终端请求。控制器ActionServlet主要负责将HTTP的客户请求信息组装后,根据配置文件的指定描述,转发到适当的处理器。
按照Servelt的标准,所有得Servlet必须在web配置文件(web.xml)声明。同样,ActoinServlet必须在Web Application配置文件(web.xml)中描述,有关配置信息如下。
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
</servlet>
全部的请求URI以*.do的模式存在并映射到这个servlet,其配置如下:
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
一个该模式的请求URI符合如下格式:
http://www.my_site_name.com/mycontext/actionName.do
中心控制器为所有的表示层请求提供了一个集中的访问点。这个控制器提供的抽象概念减轻了开发者建立公共应用系统服务的困难,如管理视图、会话及表单数据。它也提供一个通用机制如错误及异常处理,导航,国际化,数据验证,数据转换等。
当用户向服务器端提交请求的时候,实际上信息是首先发送到控制器ActionServlet,一旦控制器获得了请求,其就会将请求信息传交给一些辅助类(help classes)处理。这些辅助类知道如何去处理与请求信息所对应的业务操作。在Struts中,这个辅助类就是org.apache.struts.action.Action。通常开发者需要自己继承Aciton类,从而实现自己的Action实例。

Struts中最核心的类和包有哪些?

1. org.apache.struts.action
基本上,控制整个struts framework的运行的核心类、组件都在这个包中,比如我们上面提到的控制器ActionServlet。已经Action,ActionForm,ActionMapping等等。struts1.1比1.0多了 DynaActionForm 类。增加了动态扩展生成FormBean功能
2. org.apache.struts.actions
这个包是主要作用是提供客户的http请求和业务逻辑处理之间的特定适配器转换功能,而1.0版本中的部分动态增删FromBean的类,也在struts1.1中被Action包的DynaActionForm组件所取代
3. org.apache.struts.config
提供对配置文件struts-config.xml元素的映射。这也是sturts1.1中新增的功能
4. org.apache.struts.util
Strtuts为了更好支持web application的应用,体统了一个些常用服务的支持,比如Connection Pool和Message Source。详细信息请参考
http://jakarta.apache.org/struts/api/org/apache/struts/util/package-summary.html
5. org.apache.struts.taglib
这不是一个包,而是是一个客户标签类的集合。下面包括Bean Tags,HTML Tags,Logic Tags,Nested Tags,Template Tags这几个用于构建用户界面的标签类。
6 . org.apache.struts.validator
Struts1.1 framework中增加了validator framework,用于动态的配置from表单的验证。

如何配置spring+struts?

在struts-config.xml加入一个插件,通过它加载applicationContext.xml
 在struts-config.xml修改action-mapping标记,具体action交给了DelegateActionProxy?
 通过DelegateActionProxy进入一spring的环境。u
 在spring的applicationContext.xml加入?<bean name=”/login” class=”" singleton=”false”/>

Spring和Struts的区别?

strusts:是一种基于MVC模式的一个web层的处理。
Spring:提供了通用的服务,ioc/di aop,关心的不仅仅web层,应当j2ee整体的一个服务,可以很容易融合不同的技术struts hibernate ibatis ejb remote springJDBC springMVC

 

如何用Struts实现国际化?

国际化:不用修改代码,就适用于不同的语言国家
本地化:如果要适应一个国家,要修改源代码
实现过程:
 在struts-config.xml中用如下标签说明资源文件名,注意其只是文件名,没有语言_国家
   <message-resources parameter=”struts.ApplicationResources” />
 在资源文件对应的目录struts中加入适应不同语言、国家的properties文件
  ApplicationResources_zh_CN.properties 中国
  ApplicationResources_en_US.properties us
 如果不是英语要转码
  native2ascii -encoding gb2312 源 ApplicationResources_zh_CN.properties
 在jsp页面中用
  <bean:message key=”"/>取出信息

如何实现struts的validator框架?

手动:
   public class myForm extends ActionForm ?
   {?
    public? ActionErrors validate()
    {?
actionErrors.add(ActionErrors.GLOBAL_MESSAGE,new ActionMessage(”properties中的键名”));
    }?
   } ?
   struts-config.xml中修改action的标签validate=true?
    input=”错误页面”?
   如果validate方法中的ActionErrors不为空且size?>0时
   会回到input页面。?
  自动?
   public? class myForm extends ValidateForm 
   {?
    不能覆盖validate方法。?
    //public void? validate()
    //{?
 ?
    //}?
   } ?
   在struts-config.xml文件中加入插件?
    ? <plug-in className=”org.apache.struts.validator.ValidatorPlugIn”>
    ?     <set-property property=”pathnames” value=”/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml” />
   ?   </plug-in>
 修改validation.xml中的内容?
  errors.required={0} is? required.
  errors.minlength={0} can not be less than {1} characters.?

  ?<formset>
   ?<form name=”loginForm”>
    ?<field property=”userName” depends=”required”>
     ?<arg0 key=”userName” />
    ?</field>
    ?<field property=”pwd” depends=”required,minlength”>
     ?<arg0 key=”pwd” />
     ?<arg1 key=”${var:minlength}” resource=”false”/>
     ?<var>
      ?<var-name>minlength</var-name>
      ?<var-value>6</var-value>
     ?</var>
    ?</field>
   ?</form>
  ?</formset>
  struts-config.xml中修改action的标签validate=true?
    input=”/错误页面”?

如何在struts中配置数据源在,什么文件?用什么标签?如何取出DataSource?

Struts-config.xml

<data-sources>
    <data-source key=”data” type=”org.apache.commons.dbcp.BasicDataSource”>
     <set-property property=”driverClassName”   value=”com.microsoft.jdbc.sqlserver.SQLServerDriver” />
      <set-property property=”url”     value=”jdbc:microsoft:sqlserver://localhost:1433;databaseName=t23″ />
      <set-property property=”username” value=”sa” />
       <set-property property=”password” value=”" />    
   </data-source>
 </data-sources>

DataSource ds=(DataSource)this.getServlet().getServletContext().getAttribute(”data”);
  Connection con=ds.getConnection();

谈谈struts2的工作原理:

上图来源于Struts2官方站点,是Struts 2 的整体结构。 
一个请求在Struts2框架中的处理大概分为以下几个步骤 
1 客户端初始化一个指向Servlet容器(例如Tomcat)的请求 
2 这个请求经过一系列的过滤器(Filter)(这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器,这个过滤器对于Struts2和其他框架的集成很有帮助,例如:SiteMesh Plugin) 
3 接着FilterDispatcher被调用,FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action 
4 如果ActionMapper决定需要调用某个Action,FilterDispatcher把请求的处理交给ActionProxy 
5 ActionProxy通过Configuration Manager询问框架的配置文件,找到需要调用的Action类 
6 ActionProxy创建一个ActionInvocation的实例。 
7 ActionInvocation实例使用命名模式来调用,在调用Action的过程前后,涉及到相关拦截器(Intercepter)的调用。 
8 一旦Action执行完毕,ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是(但不总是,也可 能是另外的一个Action链)一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper 

在上述过程中所有的对象(Action,Results,Interceptors,等)都是通过ObjectFactory来创建的。

struts的工作原理:

1、初始化,读取struts-config.xml、web.xml等配置文件(所有配置文件的初始化)
2、发送HTTP请求,客户端发送以.do结尾的请求
3、填充FormBean(实例化、复位、填充数据、校验、保存)
4、将请求转发到Action(调用Action的execute()方法)
5、处理业务(可以调用后台类,返回ActionForward对象)
6、返回目标响应对象(从Action返回到ActionServlet)
7、转换Http请求到目标响应对象(查找响应,根据返回的Forward keyword)
8、Http响应,返回到Jsp页面

说下Struts的设计模式:

MVC模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时,一个配置好的ActionForm对象被创建,并被填入表单相应的数 据,ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证,如果需要就调用ActionForm的 Validate()验证后选择将请求发送到哪个Action,如果Action不存在,ActionServlet会先创建这个对象,然后调用 Action的execute()方法。Execute()从ActionForm对象中获取数据,完成业务逻辑,返回一个ActionForward对 象,ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件,ActionForward对象指定的jsp生成动 态的网页,返回给客户。

Struts工作机制?为什么要使用Struts?

工作机制: 
Struts的工作流程: 
在web应用启动时就会加载初始化ActionServlet,ActionServlet从 
struts-config.xml文件中读取配置信息,把它们存放到各种配置对象 
当ActionServlet接收到一个客户请求时,将执行如下流程. 
    -(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息; 
    -(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中; 
    -(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法; 
    -(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功; 
    -(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的                    Action实例不存在,就先创建这个实例,然后调用Action的execute()方法; 
    -(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件; 
    -(7)ActionForward对象指向JSP组件生成动态网页,返回给客户; 

为什么要用: 
JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱,所以在此之上,我们需要一个规则、一个把这些技术组织起来的规则,这就是框架,Struts便应运而生。 

基于Struts开发的应用由3类组件构成:控制器组件、模型组件、视图组件

 

你对MVC的理解,MVC有什么优缺点?结合Struts,说明在一个Web应用如何去使用?

MVC设计模式(应用观察者模式的框架模式)
M: Model(Business process layer),模型,操作数据的业务处理层,并独立于表现层(Independent of presentation)。
V: View(Presentation layer),视图,通过客户端数据类型显示数据,并回显模型层的执行结果。
C: Controller(Control layer),控制器,也就是视图层和模型层桥梁,控制数据的流向,接受视图层发出的事件,并重绘视图

MVC框架的一种实现模型
模型二(Servlet-centric):
JSP+Servlet+JavaBean,以控制为核心,JSP只负责显示和收集数据,Sevlet,连接视图和模型,将视图层数据,发送给模型层,JavaBean,分为业务类和数据实体,业务类处理业务数据,数据实体,承载数据,基本上大多数的项目都是使用这种MVC的实现模式。

StrutsMVC框架(Web application frameworks)

Struts是使用MVC的实现模式二来实现的,也就是以控制器为核心。

Struts提供了一些组件使用MVC开发应用程序:
Model:Struts没有提供model类。这个商业逻辑必须由Web应用程序的开发者以JavaBean或EJB的形式提供

View:Struts提供了action form创建form bean, 用于在controller和view间传输数据。此外,Struts提供了自定义JSP标签库,辅助开发者用JSP创建交互式的以表单为基础的应用程序,应用程序资源文件保留了一些文本常量和错误消息,可转变为其它语言,可用于JSP中。

Controller:Struts提供了一个核心的控制器ActionServlet,通过这个核心的控制器来调用其他用户注册了的自定义的控制器Action,自定义Action需要符合Struts的自定义Action规范,还需要在struts-config.xml的特定配置文件中进行配置,接收JSP输入字段形成Action form,然后调用一个Action控制器。Action控制器中提供了model的逻辑接口。

 

四、JDK1.5相比于JDK1.4主要有哪些新特性?

五、如何理解软件的模块独立性?

六、如何设计实现外网数据库和内网数据库的数据交换?

七、Spring最有用的功能是什么?举例说明IOC和AOP的作用。

IOC:

目前,存在的依赖注入类型有3种:基于设值(setter-based)方法、基于构建器(constructor-based)以及基于接口(interface-based)注入。Spring IoC支持前两种。依赖注入式Spring框架的基础。Spring还提供了Spring MVC框架、事务管理框架、DAO支持、支持主流的O/R Mapping工具、支持各种标准J2EE组件技术的集成(JMS/JavaMail/EJB/Web服务等)、集成各种视图(Web视图和非Web视图)技术。这是使用Spring IoC容器优于其他IoC容器的理由。

     控制反转(Inversion of Control,英文缩写为IoC)是一个重要的面向对象编程的法则来削减计算机程序的耦合问题,也是轻量级的Spring框架的核心。 控制反转还有一个名字叫做依赖注入(Dependency Injection)。简称DI

    IoC就是IoC,不是什么技术,与GoF一样,是一种设计模式。IoC设计模式重点关注组件的依赖性、配置以及生命周期。当然,IoC也适用于简单类,而不只是组件。除了具有“Dependency Injection”的昵称外,还有另外一个称呼,即Hollywood原则("Don't call me,I'll call you",即不要调用我,我将调用你)。通常,应用代码需要告知容器或框架,让它们找到自身所需要的类,然后再由应用代码创建待使用的对象实例。因此,应用代码在使用实例之前,需要创建对象实例。然而,IoC将创建对象实例的任务交个IoC容器或者框架(注,实现了IoC设计模式的框架,有时候也称为IoC容器),使得应用代码只需要直接使用实例,这就是IoC。

使用IoC,能够提供如下几方面的优势:

a、应用组件不需要在运行时寻找其协作者,因此更易于开发和编写应用。在许多IoC容器中,借助于设值方法能够在运行时将组件依赖的其他组件注入进来。比如,IoC容器中对组件对JNDI的查找工作。

b、由于借助了IoC容器管理组件的依赖关系,使得应用的单元测试和集成测试更利于展开。

c、通常,在借助于IoC容器管理业务对象的前提下,很少需要使用具体IoC容器提供的API。这使得集成现有的遗留应用成为可能。

因此,通过使用IoC能够降低组件之间的耦合度。最终,能够提高类的重用性,更利于测试,而且整个产品或系统更利于集成和配置。

IoC容器有:Spring、PicoContainer、Apache HiveMind

八、关于sql的面试题:sql语句性能调优的方法有哪些?

Hibernate面试题部分

Hibernate对象的三种状态是什么?

瞬时态(Transient)、 持久态(Persistent)、脱管态(Detached)。处于持久态的对象也称为PO(Persistence Object),瞬时对象和脱管对象也称为VO(Value Object)。

瞬时态

由new命令开辟内存空间的java对象,

eg. Person person = new Person(”amigo”, “女”);

如果没有变量对该对象进行引用,它将被java虚拟机回收。

瞬时对象在内存孤立存在,它是携带信息的载体,不和数据库的数据有任何关联关系,在Hibernate中,可通过session的save()或 saveOrUpdate()方法将瞬时对象与数据库相关联,并将数据对应的插入数据库中,此时该瞬时对象转变成持久化对象。

持久态

处于该状态的对象在数据库中具有对应的记录,并拥有一个持久化标识。如果是用hibernate的delete()方法,对应的持久对象就变成瞬时对象,因数据库中的对应数据已被删除,该对象不再与数据库的记录关联。

当一个session执行close()或clear()、evict()之后,持久对象变成脱管对象,此时持久对象会变成脱管对象,此时该对象虽然具有数据库识别值,但它已不在HIbernate持久层的管理之下。

持久对象具有如下特点:

1. 和session实例关联;

2. 在数据库中有与之关联的记录。

脱管态

当与某持久对象关联的session被关闭后,该持久对象转变为脱管对象。当脱管对象被重新关联到session上时,并再次转变成持久对象。

脱管对象拥有数据库的识别值,可通过update()、saveOrUpdate()等方法,转变成持久对象。

脱管对象具有如下特点:

1. 本质上与瞬时对象相同,在没有任何变量引用它时,JVM会在适当的时候将它回收;

2.   比瞬时对象多了一个数据库记录标识值。

 

Detached Object(游离对象)有什么好处?

Detached Object(游离对象)可以传递到任何层直到表现层而不是用任何DTO(Data Transfer Objects). 然后你还可以重新把游离对象赋给另外一个Session.

jdbc、hibernate、ibatis的区别?

jdbc:手动
  手动写sql
  delete、insert、update要将对象的值一个一个取出传到sql中,不能直接传入一个对象。
  select:返回的是一个resultset,要从ResultSet中一行一行、一个字段一个字段的取出,然后封装到一个对象中,不直接返回一个对象。
 ibatis的特点:半自动化
  sql要手动写
  delete、insert、update:直接传入一个对象
  select:直接返回一个对象   
 hibernate:全自动
  不写sql,自动封装
  delete、insert、update:直接传入一个对象
  select:直接返回一个对象

Hibernate如何实现数据表映射的继承关系?

1、两个表,子类重复父类的属性。
 2、一个表,子类父类共用一个表
    <class name=”Users” table=”users” discriminator-value=”Users”>
   <discriminator column=”DISCRIMINATOR_USERTYPE” type=”string”/>
<subclass name=”admin” discriminator-value=”admin”>
           <property name=”adminRemark” column=”admin_remark” type=”string” />
        </subclass>
    </class>
 3、两个表,子类引用父类的主键,享用公共的字段或属性。
    <class name=”Users” table=”users”>
        <id name=”userid” column=”USERID” type=”string”>
            <generator class=”assigned”/>
        </id>
        <property name=”pwd” column=”pwd” type=”string” />
   <joined-subclass name=”Guest” table=”guest”>
    <key column=”USERID”/>
         <property name=”guestRemark” column=”guest_remark” type=”string” />
        </joined-subclass>
</class>
批量删除
 Query query=session.createQuery(”update”或”delete”);
 query.executeUpdate();

Hibernate中Query对象的使用

1 个或多个属性查询:
 Query query=session.createQuery(”select customername,customerid from Customer”)
 List l=query.list();
 For(int i=0;i<l.size();i++)
{
 Obejct[] object=(Object[])l.get(i);
 Object[0]  object[1]
}
}
分组: “select count(*),productname from Product group by productname order by productname”
取值与属性一样
配置的查询,在*.hbm.xml中
 <query name=”sql”>
    <![CDATA[
     from Product where productid=:productid
    ]]>
</query>
 Query query=session.getNamedQuery(sql);
联接1
 ”from Customer as customer join fetch customer.buySet”:将多的放到buySet属性中,得出的结是Customer有一个,Buy有多个
联接2
“from Customer as customer join customer.buySet”:得出的对象,customer与buy是1对1
子查询:
 ”from Customer as customer where (select count(*) from customer.buySet)>1″

Hibernate中Criteria 和DetachedCriteria的作用是什么?

Criteria c=session.createCriteria(Customer.class);
 //设置条件
 c.add(Expression.ge(“字段名”,”值对象”))
  ge:>=
  gt:>
  le:<=
  lt:<
  eq:=
 //排序
  c.addOrder(Order.asc(“字段名”))
 //分页
  c.setFirstResult(1)//从第2行开始提取
  c.setMaxResults(5)//返回5行

 DetachedCriteria产生时不需要session
 DetachedCriteria dc= DetachedCriteria.forClass(Customer.class)
 Criteria c=Dc.getExecutableCriteria(session)

Hibernate中数据表映射关系主要有什么类型?

one-to-many
 inverse:主控方,外键的关系有谁控制
  inverse=false 是主控方,外键是由它控制的   
  inverse=true 是被控方,外键与它没关系
  要想实现主控方的控制必须将被控方作为主控方的属性
 cascade:级联
  主表增从表增
  主表修从表修
  主表删从表删
 lazy:延迟
  lazy=false:一下将所有的内容取出,不延时(常用)
  lazy=true:取出部分内容,其余内容动态去取
  通过get可以取出对方的所有内容

hibernate的核心类是什么,它们的相互关系是什么?重要的方法是什么?

Configuration
SessionFactory
  Session如下方法
   Save
   load
   Update
   Delete
      Query q=CreateQuery(“from Customer where customerName=:customerName”)
   beginTransaction
   close
   Transaction
   Commit()

在myeclipse加入hibernate环境的全过程是什么?

1.Db-browers加入配置连接
2.新建工程
3.加入hibernate环境,指定*.hbm.xml及HibernateSessionFactory文件所在的位置

面试中常出现的两个Hibernate面试题及解答

1.在数据库中条件查询速度很慢的时候,如何优化?
1.建索引
2.减少表之间的关联
3.优化sql,尽量让sql很快定位数据,不要让sql做全表查询,应该走索引,把数据量大的表排在前面
4.简化查询字段,没用的字段不要,已经对返回结果的控制,尽量返回少量数据

[2.在hibernate中进行多表查询,每个表中各取几个字段,也就是说查询出来的结果集并没有一个实体类与之对应,如何解决这个问题?
解决方案一,按照Object[]数据取出数据,然后自己组bean
解决方案二,对每个表的bean写构造函数,比如表一要查出field1,field2两个字段,那么有一个构造函数就是Bean(type1 filed1,type2 field2) ,然后在hql里面就可以直接生成这个bean了。具体怎么用请看相关文档,我说的不是很清楚。
session.load()和session.get()的区别
Session.load/get方法均可以根据指定的实体类和id从数据库读取记录,并返回与之对应的实体对象。其区别在于:

如果未能发现符合条件的记录,get方法返回null,而load方法会抛出一个ObjectNotFoundException。
Load方法可返回实体的代理类实例,而get方法永远直接返回实体类。
load方法可以充分利用内部缓存和二级缓存中的现有数据,而get方法则仅仅在内部缓存中进行数据查找,如没有发现对应数据,将越过二级缓存,直接调用SQL完成数据读取。
Session在加载实体对象时,将经过的过程:

首先,Hibernate中维持了两级缓存。第一级缓存由Session实例维护,其中保持了Session当前所有关联实体的数据,也称为内部缓存。而第二级缓存则存在于SessionFactory层次,由当前所有由本 SessionFactory构造的Session实例共享。出于性能考虑,避免无谓的数据库访问,Session在调用数据库查询功能之前,会先在缓存中进行查询。首先在第一级缓存中,通过实体类型和id进行查找,如果第一级缓存查找命中,且数据状态合法,则直接返回。
之后,Session会在当前“NonExists”记录中进行查找,如果“NonExists”记录中存在同样的查询条件,则返回null。 “NonExists”记录了当前Session实例在之前所有查询操作中,未能查询到有效数据的查询条件(相当于一个查询黑名单列表)。如此一来,如果 Session中一个无效的查询条件重复出现,即可迅速作出判断,从而获得最佳的性能表现。
对于load方法而言,如果内部缓存中未发现有效数据,则查询第二级缓存,如果第二级缓存命中,则返回。
如在缓存中未发现有效数据,则发起数据库查询操作(Select SQL),如经过查询未发现对应记录,则将此次查询的信息在“NonExists”中加以记录,并返回null。
根据映射配置和Select SQL得到的ResultSet,创建对应的数据对象。
将其数据对象纳入当前Session实体管理容器(一级缓存)。
执行Interceptor.onLoad方法(如果有对应的Interceptor)。
将数据对象纳入二级缓存。
如果数据对象实现了LifeCycle接口,则调用数据对象的onLoad方法。
返回数据对象。
Hibernate的主键生成机制
1) assigned
主键由外部程序负责生成,无需Hibernate参与。
2) hilo
通过hi/lo 算法实现的主键生成机制,需要额外的数据库表保存主键生成历史状态。
3) seqhilo
与hilo 类似,通过hi/lo 算法实现的主键生成机制,只是主键历史状态保存在Sequence中,适用于支持Sequence的数据库,如Oracle。
4) increment
主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量,以保存着当前的最大值,之后每次需要生成主键的时候将此值加1作为主键。这种方式可能产生的问题是:如果当前有多个实例访问同一个数据库,那么由于各个实例各自维护主键状态,不同实例可能生成同样的主键,从而造成主键重复异常。因此,如果同一数据库有多个实例访问,此方式必须避免使用。
5) identity
采用数据库提供的主键生成机制。如DB2、SQL Server、MySQL中的主键生成机制。
6) sequence
采用数据库提供的sequence 机制生成主键。如Oralce 中的Sequence。
7) native
由Hibernate根据底层数据库自行判断采用identity、hilo、sequence其中一种作为主键生成方式。
8) uuid.hex
由Hibernate基于128 位唯一值产生算法生成16 进制数值(编码后以长度32 的字符串表示)作为主键。
9) uuid.string
与uuid.hex 类似,只是生成的主键未进行编码(长度16)。在某些数据库中可能出现问题(如PostgreSQL)。
10) foreign
使用外部表的字段作为主键。一般而言,利用uuid.hex方式生成主键将提供最好的性能和数据库平台适应性。
这10中生成OID标识符的方法,increment 比较常用,把标识符生成的权力交给Hibernate处理.但是当同时多个Hibernate应用操作同一个数据库,甚至同一张表的时候.就推荐使用identity 依赖底层数据库实现,但是数据库必须支持自动增长,当然针对不同的数据库选择不同的方法.如果你不能确定你使用的数据库具体支持什么的情况下.可以选择用native 让Hibernate来帮选择identity,sequence,或hilo.
另外由于常用的数据库,如Oracle、DB2、SQLServer、MySql 等,都提供了易用的主键生成机制(Auto-Increase 字段或者Sequence)。我们可以在数据库提供的主键生成机制上,采用generator-class=native的主键生成方式。
不过值得注意的是,一些数据库提供的主键生成机制在效率上未必最佳,大量并发insert数据时可能会引起表之间的互锁。数据库提供的主键生成机制,往往是通过在一个内部表中保存当前主键状态(如对于自增型主键而言,此内部表中就维护着当前的最大值和递增量),之后每次插入数据会读取这个最大值,然后加上递增量作为新记录的主键,之后再把这个新的最大值更新回内部表中,这样,一次Insert操作可能导致数据库内部多次表读写操作,同时伴随的还有数据的加锁解锁操作,这对性能产生了较大影响。因此,对于并发Insert要求较高的系统,推荐采用uuid.hex 作为主键生成机制

 

Hibernate工作原理

  1. 读取并解析配置文件
  2. 读取并解析映射信息,创建SessionFactory
  3. 打开Sesssion
  4. 创建事务Transation
  5. 持久化操作
  6. 提交事务
  7. 关闭Session
  8. 关闭SesstionFactory

Hibernate有什么好处:

  • 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。
  • Hibernate是一个基于JDBC的主流持久化框架,是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
  • hibernate使用Java反射机制,而不是字节码增强程序来实现透明性。
  • hibernate的性能非常好,因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库,从一对一到多对多的各种复杂关系。

Hibernate是如何延迟加载的:

  • Hibernate2延迟加载实现:a)实体对象 b)集合(Collection)
  • Hibernate3 提供了属性的延迟加载功能

Hibernate的查询方式:

Sql、Criteria,object comptosition 
Hql:

  • 属性查询
  • 参数查询、命名参数查询
  • 关联查询
  • 分页查询
  • 统计函数

说下Hibernate的缓存机制:

  • 使用双向一对多关联,不使用单向一对多
  • 灵活使用单向一对多关联
  • 不用一对一,用多对一取代
  • 配置对象缓存,不使用集合缓存
  • 一对多集合使用Bag,多对多集合使用Set
  • 继承类使用显式多态
  • 表字段要少,表关联不要怕多,有二级缓存撑腰
  • 内部缓存存在Hibernate中又叫一级缓存,属于应用事物级缓存
  • 二级缓存:

如何优化Hibernate:

a)应用及缓存 
b)分布式缓存 
条件:数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据 
c) 第三方缓存的实现

 

Spring面试题部分

请介绍一下Spring的事务管理?

spring提供了几个关于事务处理的类:
TransactionDefinition //事务属性定义
TranscationStatus //代表了当前的事务,可以提交,回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口,其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤:

TransactionDefinition td = new TransactionDefinition();
TransactionStatus ts = transactionManager.getTransaction(td);
try
{ //do sth
transactionManager.commit(ts);
}
catch(Exception e){transactionManager.rollback(ts);}

spring提供的事务管理可以分为两类:编程式的和声明式的。编程式的,比较灵活,但是代码量大,存在重复的代码比较多;声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。省略了部分的提交,回滚,一系列的事务对象定义,需注入事务管理对象.
void add()
{
transactionTemplate.execute( new TransactionCallback(){
pulic Object doInTransaction(TransactionStatus ts)
{ //do sth}
}
}

声明式:

使用TransactionProxyFactoryBean:

PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly

围绕Poxy的动态代理 能够自动的提交和回滚事务
org.springframework.transaction.interceptor.TransactionProxyFactoryBean

PROPAGATION_REQUIRED–支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS–支持当前事务,如果当前没有事务,就以非事务方式执行。

PROPAGATION_MANDATORY–支持当前事务,如果当前没有事务,就抛出异常。

PROPAGATION_REQUIRES_NEW–新建事务,如果当前存在事务,把当前事务挂起。

PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。

PROPAGATION_NEVER–以非事务方式执行,如果当前存在事务,则抛出异常。

PROPAGATION_NESTED–如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则进行与PROPAGATION_REQUIRED类似的操作。

1、 如何在Spring的applicationContext.xml里面使用JNDI而不是datasource?

可以使用”org.springframework.jndi.JndiObjectFactoryBean”来实现。示例如下:
<bean id=”dataSource”>
    <property name=”jndiName”>
        <value>java:comp/env/jdbc/appfuse</value>
    </property>
</bean>

Spring里面如何配置数据库驱动?

使用”org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下:
<bean id=”dataSource”>
    <property name=”driverClassName”>
        <value>org.hsqldb.jdbcDriver</value>
    </property>
    <property name=”url”>
        <value>jdbc:hsqldb:db/appfuse</value>
    </property>
    <property name=”username”><value>sa</value></property>
    <property name=”password”><value></value></property>
</bean>

2、 Spring里面applicationContext.xml文件能不能改成其他文件名?

ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下, 它会在WEB-INF/applicationContext.xml文件找Spring的配置。 你可以通过定义一个<context-param>元素名字为”contextConfigLocation”来改变Spring配置文件的位置。示例如下:

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener
 

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/xyz.xml</param-value>
    </context-param>
 

    </listener-class>
</listener>

如何在web应用里面配置spring?

在J2EE的web应用里面配置spring非常简单,最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了,示例如下:
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

Spring里面如何定义hibernate mapping?

添加hibernate mapping 文件到web/WEB-INF目录下的applicationContext.xml文件里面。示例如下:
<property name=”mappingResources”>
    <list>
        <value>org/appfuse/model/User.hbm.xml</value>
    </list>
</property>

两种依赖注入的类型都是什么?

两种依赖注入的类型分别是setter注入和构造方法注入。

setter注入: 一般情况下所有的java bean, 我们都会使用setter方法和getter方法去设置和获取属性的值,示例如下:
public class namebean {
     String      name;  
     public void setName(String a) {
        name = a; }
     public String getName() {
        return name; }
    }
我们会创建一个bean的实例然后设置属性的值,spring的配置文件如下:
<bean id=”bean1″  >
   <property   name=”name” >
       <value>tom</value>
   </property>
</bean>
Spring会调用setName方法来只是name熟悉为tom
构造方法注入:构造方法注入中,我们使用带参数的构造方法如下:
public class namebean {
     String name;
     public namebean(String a) {
        name = a;
     }   
}
我们会在创建bean实例的时候以new namebean(”tom”)的方式来设置name属性, Spring配置文件如下:
<bean id=”bean1″ >
    <constructor-arg>
       <value>My Bean Value</value>
   </constructor-arg>
</bean>
使用constructor-arg标签来设置构造方法的参数。

解释一下Dependency injection(DI,依赖注入)和IOC(Inversion of control,控制反转)?

参考答案:依赖注入DI是一个程序设计模式和架构模型, 一些时候也称作控制反转,尽管在技术上来讲,依赖注入是一个IOC的特殊实现,依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力,例如:把一个数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖
应用控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体,将其所依赖的对象的引用,传递给它。也可以说,依赖被注入到对象中。所以,控制反转是,关于一个对象如何获取他所依赖的对象的引用,这个责任的反转。

3、 spring中的BeanFactory与ApplicationContext的作用和区别?

作用:

1. BeanFactory负责读取bean配置文档,管理bean的加载,实例化,维护bean之间的依赖关系,负责bean的声明周期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外,还提供了更完整的框架功能:

a. 国际化支持
b. 资源访问:Resource rs = ctx. getResource(”classpath:config.properties”), “file:c:/config.properties”
c. 事件传递:通过实现ApplicationContextAware接口
3. 常用的获取ApplicationContext的方法:
FileSystemXmlApplicationContext:从文件系统或者url指定的xml配置文件创建,参数为配置文件名或文件名数组
ClassPathXmlApplicationContext:从classpath的xml配置文件创建,可以从jar包中读取配置文件
WebApplicationContextUtils:从web应用的根目录读取配置文件,需要先在web.xml中配置,可以配置监听器或者servlet来实现
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
这两种方式都默认配置文件为web-inf/applicationContext.xml,也可使用context-param指定配置文件
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/myApplicationContext.xml</param-value>
</context-param>

如何在web环境中配置applicationContext.xml文件?

<listener>
  <listener-class>
   org.springframework.web.context.ContextLoaderListener
  </listener-class>
 </listener>
 或:
 <servlet>
  <servlet-name>context</servlet-name>
   <servlet-class>
    org.springframework.web.context.ContextLoaderServlet
   </servlet-class>
  <load-on-startup>1</load-on-startup>
 </servlet>
 通过如下方法取出applicationContext实例:
 ApplicationContext ac=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext);

spring+hibernate的配置文件中的主要类有那些?如何配置?

在myeclipse中先加入spring环境再加入hibernate环境。
如果spring与hibernate结合在一起可以不需要hibernate.cfg.xml文件是否   正确?
 spring+hibernate的配置文件中的主要类有那些?如何配置?
  dataSource
  sessionFactory:hibernate.cfg.xml
  transactionManager
  userDao (extends HibernateDaoSupport) 
   sessionFactory
  facade
  proxy
   sessionFactory
   transactionManager
   facade

如何配置spring+struts?

在struts-config.xml加入一个插件,通过它加载applicationContext.xml
 在struts-config.xml修改action-mapping标记,具体action交给了DelegateActionProxy?
 通过DelegateActionProxy进入一spring的环境。u
 在spring的applicationContext.xml加入?<bean name=”/login” class=”" singleton=”false”/>

在spring中如何配容器的事务管理,相关的类有那些?

Datasouce
   transactionManager
   userDao要注入
    Datasouce
   Proxy代理
    Target:userDao:代理对象(目标对象)
    transactionAttributes(那些方法需要事务处理)
    transactionManager(事务处理服务)

spring中有几种事务管理,分别是什么?

代码管理的事务处理
TransactonTemplate的execute方法中的内部类TransactionCallback中的doInTransaction方法中使用。
public void make()
 { 
  TransactionTemplate jtm=new TransactionTemplate(this.getTransactionManager());
  jtm.execute(new myClass1());
 }
 public class myClass1 implements TransactionCallback
 {

  public Object doInTransaction(TransactionStatus trans)
  {
   JdbcTemplate jdbc=new JdbcTemplate(dataSource);
   jdbc.execute(”insert into customer(customerName) values(’b')”);
   jdbc.execute(”insert into customer(customerName) values(’b')”);
   return null;
  }  
 }
   容器管理的事务处理

spring的jdbc与传统的jdbc有什么区别,其核心类有那些?

Spring的jdbc:节省代码,不管连接(Connection),不管事务、不管异常、不管关闭(con.close() ps.close )

  JdbcTemplate(dataSource):增、删、改、查
  TransactionTemplate(transactionManager):进行事务处理

spring与ejb2.0的事务管理比较的优缺点?

测试:
   Spring:pojo
   Ejb:二个接口一个类,一堆配置文件
事务类型
   Spring:jdbc jta  hibernate
   Ejb:jta
成本
     Spring:普通容器(tomcat jboss)
     Ejb:weblogic jboss
开发的周期:
   Spring远比ejb快.

spring的配置的主要标签是什么?有什么作用?

<beans>
   <bean id=”” class=”” init=”” destroy=”” singleton=””>
    <property name=””>
     <value></value>
    </property>
    <property name=””>
     <ref local></ref>
    </property>
   </bean>
</beans>

如何在spring中实现国际化?

在applicationContext.xml加载一个bean
<bean

id=”messageSource” class=”org.springframework.context.support.ResourceBundleMessageSource”>
  <property name=”basename”>
   <value>message</value>
  </property>
</bean>
 在src目录下建多个properties文件?
 对于非英文的要用native2ascii? -encoding gb2312 源  目转化文件相关内容
 其命名格式是message_语言_国家。?
 页面中的中显示提示信息,键名取键值。?
 当给定国家,系统会自动加载对应的国家的properties信息。?
 通过applictionContext.getMessage(“键名”,”参数”,”区域”)取出相关的信息。?

如何加入Spring到web框架中?

在web.xml中加入如下同容,在启动web服务器时加载/WEB-INF/applicationContext.xml中的内容。
<servlet>
<servlet-name>context</servlet-name>
<servlet-class>
org.springframework.web.context.ContextLoaderServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
通过如下类得到ApplicationContext实例
   WebApplicationContextUtils.getWebApplicationContext

Spring如何实现资源管理?

使用
applicationContext.getResource(“classpath:文件名”):在src根目录下,在类路径下
applicationContext.getResource(“classpath:/chap01/文件名”): 以src根目录下的基准往下走。
applicationContext.getResource(“file:c:/a.properties”):在系统文件目录下。

Spring中ApplicationContext的作用是什么?

beanFactory
国际化(getMesage)
资源管理:可以直接读取一个文件的内容(getResource)
加入web框架中(加入一个servlet或监听器)
事件处理

spring中的核心类有那些,各有什么作用?

BeanFactory:产生一个新的实例,可以实现单例模式
BeanWrapper:提供统一的get及set方法
ApplicationContext:提供框架的实现,包括BeanFactory的所有功能

aop中的关键名词有些那些,相互关系是什么?

拦截器: 代理
装备(advice)
目标对象
关切点:条件
连接点:方法、属性

一些Spring和Hibernate的面试题

1、 简述你对IoC(Inversion of Control)的理解,描述一下Spring中实现DI(Dependency Injection)的几种方式。

2、 Spring的Bean有多种作用域,包括:

singleton、prototype、request、session、global session、application、自定义

3、 简单描述Spring framework与Struts的不同之处,整合Spring与Struts有哪些方法,哪种最好,为什么?

4、 Hibernate中的update()和saveOrUpdate()的区别

5、 Spring对多种ORM框架提供了很好的支持,简单描述在Spring中使用Hibernate的方法,并结合事务管理。

答案:

1、IoC将创建的职责从应用程序代码搬到了框架中。Spring对Setter注入和构造方法注入提供支持。(详见http://martinfowler.com/articles/injection.html,以及http: //www.redsaga.com/spring_ref/2.0/html/beans.html#beans-factory- collaborators)

2、 除application(详见Spring framework 2.0 Reference的3.4节bean的作用域)

3、 Spring是完整的一站式框架,而Struts仅是MVC框架,且着重于MVC中的C。Spring有三种方式整合Struts:使用 Spring 的 ActionSupport 类整合 Struts;使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor;将 Struts Action 管理委托给 Spring 框架,动作委托最好。(详见使用Spring 更好地处理Struts 动作)

Spring 2.0新增一种方式:AutowiringRequestProcessor。(详见http://www.javaeye.com/topic/24239)

4、 saveOrUpdate()方法可以实现update()的功能,但会多些步骤,具体如下:

如果对象在该session中已经被持久化,不进行操作;

对象的标识符属性(identifier property)在数据库中不存在或者是个暂时的值,调用save()方法保存它;

如果session中的另一个对象有相同的标识符抛出一个异常;

以上皆不符合则调用update()更新之。

5、 在context中定义DataSource,创建SessionFactoy,设置参数;DAO类继承HibernateDaoSupport,实现具体接口,从中获得HibernateTemplate进行具体操作。

在使用中如果遇到OpenSessionInView的问题,可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。(详见Spring framework 2.0 Reference的12.2节Hibernate)

声明式事务需声明事务管理器,在context中设置指定属性,用确定和。

请你谈谈SSH整合?

SSH:
Struts(表示层)+Spring(业务层)+Hibernate(持久层)
Struts:
Struts是一个表示层框架,主要作用是界面展示,接收请求,分发请求。
在MVC框架中,Struts属于VC层次,负责界面表现,负责MVC关系的分发。(View:沿用JSP,HTTP,Form,Tag,Resourse ;Controller:ActionServlet,struts-config.xml,Action)
Hibernate:
Hibernate是一个持久层框架,它只负责与关系数据库的操作。
Spring:
Spring是一个业务层框架,是一个整合的框架,能够很好地黏合表示层与持久层。

EJB面试题部分

介绍一下JMS 编程步骤?

第一步:
<一>配置管理对象
1>.配置连接工厂(ConnectionFactory)
ConnectionFactory: 在应用服务器中配置的一个对象,用来获得建立消息中间件连接对象.
2>.配置目的地
第二步:
<二>分别编写消息的发送和接收程序
1>.获取连接工厂对象(JNDI 方式查找)
2>.建立连接(Connection)
3>.创建会话(Session)
4>.获取目的地对象(JNDI)
5>.分别创建生产者对象和消费者对象
6>.使用生产者对象发送消息,使用消费者对象来接收(消费)消息
7>.关闭资源: +发送对象/接收对象+Session +Connection
2>.建立连接(Connection)
3>.创建会话(Session)

几个常见的消息中间件(MOM)?

IBM WebSphere MQ
BEA tuxedo/Q
Tibco Rendezvous
Microsoft MSMQ

异步传递消息系统的作用是什么?

异步编程,客户端发送请求给消息的接收方,不用等待接收方的反馈,可以继续执行.
解耦,消息发送方只负责发送消息,并不关心由谁来消费.
可靠性,消息的服务器能够保证一定会被发送给消息的消费者.当消息的发送方发送消息时不
要求接收方一定在运行.
支持多个消息的发送方和接收方.

实体的生命周期

1>.暂态(瞬态)
没有纳入持久化上下文,无主健值,数据库中无对应的记录.
2>.受管状态(持久化状态)
纳入了持久化上下文,有主健值,数据库中有对应的记录.
3>.游离态
没纳入持久化上下文,有主健值,有无记录不确定.
4>.删除状态
调用EntityManager.remove()方法时,实体并没被删除,而是处于这种状态.
纳入了持久化上下文,数据库中会删除记录,当调用persist()方法可以重新恢复受管状态.
persist() 或find() 或remove() clear() 或close()
暂态———————————————->受管状态———————————->游离态
merge() remove()
游离态—————–>受管状态———————>删除状态
refresh()将受管状态的对象同步到数据库
flush()将数据库里同步的记录更新受管状态的对象

EntityManager都有哪些方法

persist(Object obj) 相当于Session 的save()
refresh(Object entity) 相当于Session 的flush()
remove(Object entity) 相当于Session 的update()
find(Class<T> entityClass, Object primaryKey) 例: find(Acount.class,aid)
contains() 判断受管对象是否存在
setFlushMode()/getFlushMode() 设置/获得刷新模式

如何获得EntityManager ?

1.在容器内部使用,使用@PersistenceContext 来注入.
@PersistenceContext
private EntityManager em;
TAG
============================================================
注入:
让容器来负责构建一个实体管理器,并且将该实体管理器注入到Bean 中.
============================================================
2.在容器外部使用
Persistence 构造一个EntityManagerFactory , 然后再构造EntityManager.
Code:
EntityManagerFactory emf = Persistence.createEntityManagerFactory();
EntityManager em = emf.createEntityManager();
写persistence.xml
<persistence-unit name=”firstejb”>
持久化单元名,在一个persistence.xml 中可以有多个持久化单元,用名字来区分.
如果只有一个就可以省略不写.
<provider>: 告诉容器持久化提供者是哪一个
<jta-data-source>: 数据源的位置(JNDI 名称)
<properties>: 表的生成策略

JPA的特点

A>.JPA 提供了一套标准的持久化API 和查询语言, O/R mapping 产品作为”持久化提供者”在
底层支持JPA.
B>.JPA 可以在容器中运行,也可以脱离容器运行.
C>.JPA 的持久化不倚赖于具体的持久化提供者.

EJB3推出JPA的原因?

(1).EJB2.0/2.1: 实体Bean,是一种EJB,作用是负责持久化操作.
缺点: 性能低,开发复杂度大,对O/R mapping 支持不够高,不能脱离EJB 容器运行.
(2).O/R mapping 产品: Hibernate, JDO, 持久化API.操作起来各不相同,不利于维护

EJB发布WEB 服务一般步骤

1.编写EJB(无状态会话Bean)
2.给EJB 添加WEB 服务相关的标注(@WebService,@WebMethod)
3.部署(容器生成WSDL)
4.测试WEB 服务(利用工具,如终端管理工具)

如何将无状态会话Bean 发布为WEB 服务,只有无状态会话Bean 可以发布为WEB 服务?

1.两种方式编程
(1).先写Java 类,让容器生成WSDL.
(2).先写WSDL,再用WSDL 生成Java 类.
2.编程步骤
@WebService
标注该会话Bean 发布为Web 服务.
serviceName : 标注服务的名称.
@WebMethod
标注该方法应该发布到Web 服务描述文件之中.如果所有方法都没加该标注,则所有的方法
都会发布到Web 服务描述文件中.

解释一下钝化(Swap out)?

有状态会话Bean 的实例保存有客户端状态,当容器需要使用该实例为其他客户服务时,需要
将客户端状态保存到持久化设备(硬盘).
容器按照LRU(最近最少被使用)算法将Bean 以前的状态钝化

会话Bean的种类有哪些?

1.无状态会话Bean.
1).一次方法(单方法)完成一个相对完整的业务处理.
2).不保存客户端的状态.(可以有属性,但属性不保存(维护)客户端的状态)
3).无状态会话Bean 可以非常方便的构造pooling(池)
4).无状态会话Bean 的生命周期分两个阶段: 不存在状态和就绪状态.
1>.调用缺省的构造器构造一个实例
2>.如果有一来流入则注入相应的资源
3>.如果有@PostConstruct 标注的方法,则完成初始化.
4>.EJB 实例处于就绪状态可以接收调用.
5>.当容器删除实例之前如果有@PreDestroy 标注的方法则执行.(完成资源的释放)
2.有状态会话Bean.
1).多次方法调用完成一个相对完整的业务处理过程.
2).必需保存客户端的状态.
例: ShoppingCart Bean
3).有状态会话Bean 不方便构造Pooling, 需要处理状态的钝化和激活.

什么是会话Bean

1.用来建模业务流程的EJB 中的一种类型.
2.会话Bean 的生命周期很短(存在时间),主要取决于客户端与会话Bean 的调用的时间长度.

为什么要用EJB

EJB 能为我们提供中间件服务
Remote Method Invocations(RMI) 远程方法调用(跨越JVM,网络,实现一个对象调用另一个对
象的方法)
Load Balancing 负载均衡(如多个Tomcat 组成一个Server 集群)

什么是组件架构?

企业级程序: 基础服务+ 应用逻辑
企业级程序概念:
1>.围绕商业目的2>.表示层,基于网络连接在一起,分层,分布
应用逻辑: 业务流程
基础服务: 事务,安全,并发,缓存,持久化,公用的服务
基础服务+ 应用逻辑
| |
容器(服务器开发商) 组件(开发人员)
组件架构: 协议,接口(Sun 提供),实现容器和组件接合到一起
容器提供基础服务,组件负责业务逻辑处理,组件在容器中运行,容器依照相关配置文件或标
准来调用组件,并为组件提供中间件服务.

介绍一下EJB的分类及其各自的功能及应用?

在EJB2.0中定义了三种不同类别的EJB:Session Bean(会话Bean)、Entity Bean(实体Bean)和Message-Driven Bean(消息驱动Bean)[2]。

1 会话Bean
会话Bean是商务过程对象,执行商务逻辑、规则和工作流程。会话Bean之所以被称为会话Bean,是因为它代表的是一个动作、是一个过程,它的生存期就是调用它的客户端与它进行会话的过程。

会话Bean根据其是否保存客户的状态,又分为状态会话Bean和无状态会话Bean。状态会话Bean是一种保持会话状态的服务,每个实例都与特定的客户机相关联,在与客户机的方法调用之间维持对话状态。与之相反,无状态会话Bean不保存与特定客户的对话状态。因此状态会话Bean比无状态会话Bean具有更多的功能,而无状态会话Bean实例可以通过 EJB容器自由地在客户机之间交换,从而少量的会话Bean就可以服务于大量的客户机。

2 实体Bean

实体Bean代表商务上的实体,比如商务数据,应该包含与数据相关的逻辑。实体Bean是对应到数据库中的一个视图,一个实体Bean实例和底层数据库完全是一回事[2]。因此,一个简单的实体bean实例代表一个特殊的记录。更复杂的实体bean可以代表数据库表间关联视图[3]。

实体Bean有两种操作类型:BMP(Bean管理持久性)和CMP(容器管理持久性)。BMP是指由Bean自己来实现实体Bean的持久性,即在Bean中实现数据库操作。而CMP则是由容器实现Bean的持久性,使我们不需要在Bean内再编写数据库操作的代码。

3 消息驱动Bean

消息驱动Bean是EJB2.0新引入的一种Bean类型。它的主要目的是,通过允许容器去聚合并且管理消息驱动Bean实例,以此来提供传入JMS消息的并发处理[4]。

4 会话Bean与实体Bean的区别和联系

会话Bean执行应用逻辑,它们隐含地使用实体Bean作为它们操作的数据。在EJB分布式对象体系结构中,会话Bean被用做代表实际商务过程的高层接口来屏蔽底层实体Bean子系统。实体Bean是实际恒定商务实体的模型,因此它通常比会话Bean具有更高层次的重复使用。

5 EJB的应用

接下来,通过分析电子购物环节的业务逻辑层的对象模型来说明各种EJB在业务逻辑层中的不同应用。

业务逻辑层包含了一系列EJB组件。首先我们将其抽象成若干个对象模型,如图所示:

图:对象模型图

本图首先反映了电子商务中各EJB组件之间的静态关系。

由多个购物篮条目(Cart Line Item)组成的一个购物篮(Cart)为一个顾客 (Customer)存储产品的临时选择;由多个订单条目(Order line Item)组成的一个订单(Order)为一个顾客存储产品的永久选择。购物篮能将自身转换为订单。

一个购物篮条目代表一个产品(Product)的临时选择,一个订单条目代表一个产品的永久选择。

估价器(Pricer)在顾客查看购物篮时计算购物篮的价格,并且在顾客最终生成订单时计算订单的价格。

订单处理器(Order Processor)为订单验证信用卡,发送E-mail确认,并标识为永久。

同时从本图中也可以了解一个电子购物的过程:首先,在购物时顾客把自己感兴趣的产品放入购物篮中,同时由估价器对购物篮进行及时估价。然后,顾客在确认购买后,购物篮能自动生成订单。再由估价器计算出订单的价格。接着,由订单处理器验证顾客信用卡的合法性,在交易完成后为顾客发送E-mail确认交易成功,并将本交易标识为永久。

顾客、订单、产品、订单条目这几个对象是永久性、持续性对象,例如,顾客信息、产品信息都需要存入数据库,并且在适当的时候从数据库中读取。所以,这几项都需要用实体Bean来实现。

购物篮和购物篮条目只在顾客购物的过程中起作用,所以不是永久性的,而且每一个购物篮都对应于一个特定的顾客,对应于若干条特定的购物车条目,因此购物篮和购物篮条目用状态会话Bean来充当最合适不过。

估价器的作用是计算出购物篮和订单的价格,它并没有和特定的顾客绑定,可以作用于任意的购物篮,而且也不是永久对象,因此估价器可以用一个无状态会话Bean来充当。

订单处理器是一个特殊的对象,它通过顾客所要求的不同的付款方式产生不同的订单,也就是说,它是由不同的付款方式来驱动的。所以在这里用消息驱动Bean是最恰当的。

通过上面的分析,我们清楚的了解到不同类型的EJB在实际应用中如何发挥自己的作用。

比较一下entity bean和session bean

entity bean(譬如说)代表底层数据库的一行,entity bean实例和数据库记录间就是一对一的关系。因为多个客户端必须访问底层记录, 这意味着,不同于session bean,客户端必须共享entity bean。因为是共享的, 所以entity bean不允许保存每个客户端的信息。session bean允许保存客户端的 状态信息,客户端和session bean实例间是一对一的。entity bean允许保存记录的信息,entity bean实例和记录间是一对一的。一个理想的情况是客户端通过session bean连接服务器,然后session bean通过entity bean访问数据库。这使得既可以保存客户端的信息又可以保存数据库记录的信息。同时session bean也不能提供在相同或不同的EJB类调用间进行全局的事务控制。没有session bean,应用程序开发者(客户端开发者)就必须理解EJB类的事务要
求,并使用客户端的事务划分来提供事务控制。EJB的主要好处就是应用开发者不需知道EJB类的事务需求。一个session bean可以代表一个商业操作,进行事务控制,不需要客户端进行事务划分

分别介绍一下Session Bean 和 Entity Bean

Session beans:

  Session beans 是一种作为单个的client执行的对象。作为对远程的任务请求的相应,容器产生一个Session beans 的实例。一个Session beans有一个client.从某种程度上来说,一个Session bean 对于服务器来说就代表了它的那个client.Session beans 也能用于事务,它能够更新共享的数据,但它不直接描绘这些共享的数据。

  Session beans 的生命周期是相对较短的。典型的是,只有当client保持会话的时候,Session beans 才是活着的。一旦client退出了,Session beans 就不再与client相联系了。Session beans被看成是瞬时的,因为如果容器崩溃了,那么client必须重新建立一个新的Session对象来继续会话。

  一个Session bean典型的声明了与client的互操作或者会话。也就是说,Session bean了在客户会话期间,通过方法的调用,掌握Client的信息。一个具有状态的Session bean称为有状态的Session bean.当client终止与Session beans互操作的时候.会话终止了,而且,bean 也不再拥有状态值。

  一个Session bean也可能是一个无状态的 session bean.无状态的Session beans并不掌握它的客户的信息或者状态。Client能够调用beans的方法来完成一些操作。但是,beans只是在方法调用的时候才知道client的参数变量。当方法调用完成以后,beans并不继续保持这些参数变量。这样,所有的无状态的session beans的实例都是相同的,除非它正在方法调用期间。这样,无状态的Session beans就能够支持多个client.容器能够声明一个无状态的Session beans.能够将任何Session beans指定给任何client.

Entity Beans:

  Entity Beans对数据库中的数据提供了一种对象的视图。例如:一个Entity bean能够模拟数据库表中一行相关的数据。多个client能够共享访问同一个Entity bean.多个client也能够同时的访问同一个Entity bean.Entity beans通过事务的上下文来访问或更新下层的数据。这样,数据的完整性就能够被保证。

  Entity Beans能存活相对教长的时间,并且状态是持续的。只要数据库中的数据存在,Entity beans就一直存活。而不是按照应用程序或者服务进程来说的。即使EJB容器崩溃了,Entity beans也是存活的。Entity Beans生命周期能够被容器或者 Beans自己管理。如果由容器控制着保证 Entity beans持续的issus。如果由Beans自己管理,就必须写Entity beans的代码,包括访问数据库的调用。

  Entity Beans是由主键(primary key 一种唯一的对象标识符)标识的。通常,主键与标识数据库中的一块数据,例如一个表中的一行,的主键是相同的。主键是client能够定位特定的数据块。

介绍一下EJB的体系结构

EJB的上层的分布式应用程序是基于对象组件模型的,低层的事务服务用了API技术。EJB技术简化了用JAVA语言编写的企业应用系统的开发,配置,和执行。EJB的体系结构的规范由Sun Microsystems公司制定。Inprise的EJB容器是基于1.1版的规范。

  EJB技术定义了一组可重用的组件:Enterprise Beans。你可以利用这些组件,象搭积木一样的建立你的分布式应用程序。当你把代码写好之后,这些组件就被组合到特定的文件中去。每个文件有一个或多个Enterprise Beans,在加上一些配置参数。最后,这些Enterprise Beans被配置到一个装了EJB容器的平台上。客户能够通过这些Beans的home接口,定位到某个beans,并产生这个beans的一个实例。这样,客户就能够调用Beans的应用方法和远程接口。

  EJB服务器作为容器和低层平台的桥梁管理着EJB容器和函数。它向EJB容器提供了访问系统服务的能力。例如:数据库的管理和事务的管理,或者对于其它的Enterprise的应用服务器。

  所有的EJB 实例都运行在EJB容器中。容器提供了系统级的服务,控制了EJB的生命周期。因为容器掌握了绝大多数系统级的issues(呵呵,不知道怎么翻译)。Enterprise Beans 的开发者不需要应用逻辑考虑进来。通常来说,EJB容器掌握了以下的系统级issues.

  1、Security–配置描述器(The Deployment descriptor)定义了客户能够访问的不同的应用函数。容器通过只允许授权的客户访问这些函数来达到这个效果。

  2、Remote Connectivity–容器为远程链接管理着低层的通信issues,而且对Enterprise Beas的开发者和客户都隐藏了通信issues.Enterprise Beans的开发者在编写应用方法的时候,就象是在条用本地的平台一样的。客户也不清楚他们调用的方法可能是在远程被处理的。

  3、Life Cycle managment–客户简单的创建一个Enterprise beans的实例,并通常取消一个实例。而容器管理着Enterprise Beans的实例,使Enterprise Beans实现最大的效能和内存利用率。容器能够这样来激活和去活Enterprise Beans,保持众多客户共享的实例池。等等。

  4、Trasction management—配置描述器定义了Enterprise beans 的事务处理的需求。容器管理着那些管理分布式事务处理的复杂的issues。这些事务可能要在不同的平台之间更新数据库。容器使这些事务之间互相独立,互不干扰。保证所有的更新数据库都是成功发生的,否者,就回滚到事务处理之前的状态

如果Session Bean得Remove方法一直都不被调用会怎么样?

如果Session Bean是无状态Bean的话,调用不调用Remove方法都没有什么关系

如果是有状态Bean的话,那么这个Bean会一直保存到Cache里面,知道Session Timeout或者Remove方法被调用。

EJB timer的种类?

从EJB容器的定时服务建立的Timer对象, Single Action Timer和Interval Timer,   Single Action Timer是相对与间隔循环型Timer来讲的, Single Action Timer只有一次timeout。Single-Action time和Interval Timer第一次启动都各有两种方法:绝对时间启动和相对时间启动。

所以总共有四种EJB timer

1. 以绝对时间启动的Single Action Timer

你可以指定一个绝对时间,但时间到达(timeout)时,这可以调用TimerService的方法来建立这个Timer:

Timer createTimer(Date expirationDate, Serializable info)

2. 以相对时间启动的Single Action Timer

你可以指定一个相对于Timer简历的时间,当这个相对时间到达时,会调用Timeout方法一次,这个调用可以通过TimerService的一下方法来建立这个Timer:

Timer createTimer(long duration, Serializable info)

3. 绝对时间的Interval Timer

你可以指定一个初始的绝对时间(initialExpiration), 当这个时间到达时,会调用Timeout方法,之后每个一段指定的时间(intervalDuration)就会重新调用Timeout方法一次, 建立这种Timer的方法:

Timer createTimer(Date initialExpiration,long intervalDuration, Serializable info)

4. 相对时间的Interval Timer

你可以指定一个相对与Timer建立的时间(initialDuration), 当时间到达时就会调用Timerout方法,之后每隔一段指定的时间(intervalDuration)就会重新调用Timeout方法一次,以下是建立这种方法的例子:

Timer createTimer(long initialDuration, long intervalDuration, Serializable info)

这四个createTimer()方法的最后一个Serializable参数,可以设定给Timer对象, Timeout的调用方法中必须接受Timer对象最为参数,你可以用它的getInfo()方法来取得传入的Serializable对象,当多个Timer与Bean关联时,必须识别Timer时间是来之于哪个Timer,也可以根据传入的Serializable对象来判断。

EJB2.0和EJB3.0之间的区别?

1. EJB2.0使用EntityBeans来访问数据库,EJB3.0是使用JPA(Java Persistance API)来访问数据库。

2. EJB2.0 有部署脚本(Deployment descriptiors),EJB3.0没有。

3. EJB3.0不需要Home接口,EJB2.0需要。

4. EJB3.0简化了开发,引入了元数据。

提高EJB性能都有哪些技巧?

1.用一个Session Bean封装多个Entity Bean,将原来的多个Entity Bean的Remote调用和Local调用封装在一个Session Bean中。所以建立一个ServerFacade,它为多个对象提供统一获取EJB Home和获取对象的接口。ServerFacade为程序要用到的所有EJB的home handle提供缓存,提高访问JNDI Name的时间,达到提高访问效率的目的。以后查找JNDI Name的方法都应写在接口里,调用时直接从接口调用。

2.在EJB的Remote接口中使用粗粒度的方法,不推荐使用细粒度方法。

3.如果EJB的Remote接口获取成功,应不再使用Remote接口,而是将Remote接口构造成一个一般的Java对象,通过调用一般的JAVA对象的方法来达到减少对网络的访问。

4.如果你部署EJB客户端和EJB在相同的JVM上,建设使用EJB2.0规范的Local接口代替Remote接口。

5.用”transient”关键字声明不必要的数据变量,替代以前的”public”、”private”等,避免不必要的数据变量占用网络资源。示例:

public class DemoCMP implements EntityBean {
transient EntityContext entCtx;
transient InitialContext initCtx;
public String id;
public String description;

}

6.在ejb-jar.XML部署文件中,对Session Bean中非事务的方法,将trans-attribute属性赋为”NotSupported”或”Never”

<ejb-jar>

<assembly-descriptor>
<container-transaction>
<method>
<ejb-name>abookesessionBean</ejb-name>
<method-name>*</method-name>
</method>
<trans-attribute>NotSupported</trans-attribute>
</container-transaction>
</assembly-descriptor>
</ejb-jar>

7. 设置事务的超时时间,在JBoss中,要修改${jboss.home}/server/${jboss.configuration}/conf/jboss-service.xml ,如下所示:

<server>

<mbean code=”org.jboss.tm.TransactionManagerService”
name=”jboss:service=TransactionManager”>
<attribute name=”TransactionTimeout”>300</attribute>
</mbean>

</server>

8.当事务锁定数据库的行记录时,事务应跨越可能的最小的时间。

9.调整EJB 服务器的各种参数,如线程数、EJB池大小、连接池参数等。以在JBoss修改连接池参数为示例,进行说明。如果JBoss和MySQL相连,配置${jboss.home}/server/${jboss.configuration}/deploy/mysql-service.xml,来修改连接池参数,包括MinSize、MaxSize、BlockingTimeoutMillis、IdleTimeoutMinutes、 Criteria等,各参数的含义如下所示:

i.MinSize :连接池保持的最小连接数。

ii. MaxSize :连接池保持的最大连接数。

iii. BlockingTimeoutMillis :抛出异常前最大的等待连接时间。

iv. IdleTimeoutMinutes :关闭连接前连接空闲的最大时间。

v. Criteria :有ByContainerAndApplication、ByContainer、ByApplication和ByNothing等值。

下面是一个例子:

<depends optional-attribute-name=”ManagedConnectionPool”>
<!–embedded mbean–>
<mbean code=”org.jboss.resource.connectionmanager.JBossManagedConnectionPool”
name=”jboss.jca:service=LocalTxPool,name=MySqlDS”>
<attribute name=”MinSize”>0</attribute>
<attribute name=”MaxSize”>50</attribute>
<attribute name=”BlockingTimeoutMillis”>5000</attribute>
<attribute name=”IdleTimeoutMinutes”>15</attribute>
<attribute name=”Criteria”>ByContainer</attribute>
</mbean>
</depends>

10.对于数据库事务,应选择较低成本的事务等级,避免造成坏数据。递增成本的事务等级包括:

TRANSACTION_READ_UNCOMMITED,
TRANSACTION_READ_COMMITED,
TRANSACTION_REPEATABLE_READ,
TRANSACTION_SERIALIZABLE

EJB包括(SessionBean,EntityBean)说出他们的生命周期,及如何管理事务的?

SessionBean:Stateless Session Bean 的生命周期是由容器决定的,当客户机发出请求要建立一个Bean的实例时,EJB容器不一定要创建一个新的Bean的实例供客户机调用,而是随便找一个现有的实例提供给客户机。当客户机第一次调用一个Stateful Session Bean 时,容器必须立即在服务器中创建一个新的Bean实例,并关联到客户机上,以后此客户机调用Stateful Session Bean 的方法时容器会把调用分派到与此客户机相关联的Bean实例。
EntityBean:Entity Beans能存活相对较长的时间,并且状态是持续的。只要数据库中的数据存在,Entity beans就一直存活。而不是按照应用程序或者服务进程来说的。即使EJB容器崩溃了,Entity beans也是存活的。Entity Beans生命周期能够被容器或者 Beans自己管理。
EJB通过以下技术管理实务:对象管理组织(OMG)的对象实务服务(OTS),Sun Microsystems的Transaction Service(JTS)、Java Transaction API(JTA),开发组(X/Open)的XA接口

EJB的基本架构?

一个EJB包括三个部分:
Remote Interface 接口的代码
package Beans;
import javax.ejb.EJBObject;
import java.rmi.RemoteException;
public interface Add extends EJBObject
{
//some method declare
}
Home Interface 接口的代码
package Beans;
import java.rmi.RemoteException;
import jaax.ejb.CreateException;
import javax.ejb.EJBHome;
public interface AddHome extends EJBHome
{
//some method declare
}
EJB类的代码
package Beans;
import java.rmi.RemoteException;
import javax.ejb.SessionBean;
import javx.ejb.SessionContext;
public class AddBean Implements SessionBean
{
//some method declare
}

1、  EJB需直接实现它的业务接口或Home接口吗,请简述理由

远程接口和Home接口不需要直接实现,他们的实现代码是由服务器产生的,程序运行中对应实现类会作为对应接口类型的实例被使用。

说说在weblogic中开发消息Bean时的persistent与non-persisten的差别

persistent方式的MDB可以保证消息传递的可靠性,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来,而non-persistent方式的消息将被丢弃。

在weblogic中发布ejb需涉及到哪些配置文件

不同类型的EJB涉及的配置文件不同,都涉及到的配置文件包括ejb-jar.xml,weblogic-ejb-jar.xmlCMP实体Bean一般还需要weblogic-cmp-rdbms-jar.xml

客服端调用EJB对象的几个基本步骤

设置JNDI服务工厂以及JNDI服务地址系统属性,查找Home接口,从Home接口调用Create方法创建Remote接口,通过Remote接口调用其业务方法。

EJB的几种类型

会话(Session)Bean ,实体(Entity)Bean 消息驱动的(Message Driven)Bean
会话Bean又可分为有状态(Stateful)和无状态(Stateless)两种
实体Bean可分为Bean管理的持续性(BMP)和容器管理的持续性(CMP)两种

EJB的激活机制

以Stateful Session Bean 为例:其Cache大小决定了内存中可以同时存在的Bean实例的数量,根据MRU或NRU算法,实例在激活和去激活状态之间迁移,激活机制是当客户端调用某个EJB实例业务方法时,如果对应EJB Object发现自己没有绑定对应的Bean实例则从其去激活Bean存储中(通过序列化机制存储实例)回复(激活)此实例。状态变迁前会调用对应的ejbActive和ejbPassivate方法。

EJB 实例的生命周期

对于Stateless Session Bean、Entity Bean、Message Driven Bean一般存在缓冲池管理,而对于Entity Bean和Statefull Session Bean存在Cache管理,通常包含创建实例,设置上下文、创建EJB Object(create)、业务方法调用、remove等过程,对于存在缓冲池管理的Bean,在create之后实例并不从内存清除,而是采用缓冲池调度机制不断重用实例,而对于存在Cache管理的Bean则通过激活和去激活机制保持Bean的状态并限制内存中实例数量。

remote接口和home接口主要作用

remote接口定义了业务方法,用于EJB客户端调用业务方法。
home接口是EJB工厂用于创建和移除查找EJB实例

EJB规范规定EJB中禁止的操作有哪些?

1.不能操作线程和线程API(线程API指非线程对象的方法如notify,wait等),2.不能操作awt,3.不能实现服务器功能,4.不能对静态属生存取,

5.不能使用IO操作直接存取文件系统,6.不能加载本地库.,7.不能将this作为变量和返回,8.不能循环调用。

EJB的角色和三个对象

一个完整的基于EJB的分布式计算结构由六个角色组成,这六个角色可以由不同的开发商提供,每个角色所作的工作必须遵循Sun公司提供的EJB规范,以保证彼此之间的兼容性。这六个角色分别是EJB组件开发者(Enterprise Bean Provider) 、应用组合者(Application Assembler)、部署者(Deployer)、EJB 服务器提供者(EJB Server Provider)、EJB 容器提供者(EJB Container Provider)、系统管理员(System Administrator)
三个对象是Remote(Local)接口、Home(LocalHome)接口,Bean类

EJB与JAVA BEAN的区别?

Java Bean 是可复用的组件,对Java Bean并没有严格的规范,理论上讲,任何一个Java类都可以是一个Bean。但通常情况下,由于Java Bean是被容器所创建(如Tomcat)的,所以Java Bean应具有一个无参的构造器,另外,通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地进程内COM组件,它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM,即分布式组件。它是基于Java的远程方法调用(RMI)技术的,所以EJB可以被远程访问(跨进程、跨计算机)。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中,EJB客户从不直接访问真正的EJB组件,而是通过其容器访问。EJB容器是EJB组件的代理,EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。

JSP和EJB可以共享HttpSession么?EJB里面可以改变session里面的内容么?

如果session里面所有的对象都是序列化的,应该可以把HttpSession作为一个参数传到EJB的方法,这样的话就是值传递,相当于这个 HttpSession是自读的,如果在EJB里面改变session的值,不会影响到Servlet容器里面的HttpSession,但是因为EJB 的远程接口之间是使用远程引用,也就是引用传递,  所以把HttpSession作为参数传到EJB对象是可能的,但是这样是有违面向对象的原则的,因为这样的话就在EJB和前端的HttpSession 之间创建了一个不必要的依赖关系,而且这样的话EJB对基于Http的客户端也产生了依赖(EJB也有可能给非Http的客户端服务的),其实与其传一整 个HttpSession对象到EJB, 还不如另外创建一个类似结构的对象过去,然后在EJB进行处理以后然后在返回客户端。

SOA面试题部分

1、         web services是SOA吗?

SOA是一种思想,它是一种架构的理念,Web Service是一种来实现这理念的技术方法, Web Service是实现SOA的推荐标准。
在SOA中,所有的服务之间要松耦合,web servcie之间的通信是通过SOAP协议进行的,SOAP协议是基于XML实现的松耦合的协议。
SOA服务需要对他们自己的服务本身进行描述,WSDL就是用来描述如何访问到SOA的服务。
SOA服务存在于一个目录中,UDDI就是用来描述从那里得到SOA服务的,只需要完成SOA的注册就可以了。

2、         解释一下什么是BPEL?

BPEL:全称为Business Process Execution Language,即业务处理执行语言,是一种使用XML编写的编程语言。用于自动化业务流程,也曾经被称作WSBPEL和 BPEL4WS。广泛使用于Web服务相关的项目开发中,优点为具有可移植性和有效保护了投资。
  BPEL是一门用于自动化业务流程的形式规约语言。 用XML文档写入BPEL中的流程能在Web 服务之间以标准化的交互方式得到精心组织。这些流程能够在任何一个符合BPEL规范的平台或产品上执行。 所以,通过允许顾客们在各种各样的创作工具和执行平台之间移动这些流程,BPEL使得他们保护了他们在流程自动化上的投资。尽管以前想使业务流程定义标准化,但BPEL已经引起了史无前例的兴趣,而且它最早在软件供应商中获得大量认可。

3、         什么是WEB 服务 Web Service?

<1>.程序间以一种标准的方式进行通讯(与程序的开发语言,运行的操作系统,硬件平台,网络
关系无关)
<2>.用SOAP,WSDL 等协议通讯,以XML 文档方式进行数据交换的网络应用程序.

4、         介绍一下SOA和SOA的基本特征?

什么是SOA
SOA:面向服务的体系结构(Service-Oriented Architecture,SOA,也叫面向服务架构), SOA是指为了解决在Internet环境下业务集成的需要,通过连接能完成特定任务的独立功能实体实现的一种软件系统架构。
SOA 是一个组件模型,它将应用程序的不同功能单元(称为服务)通过这些服务之间定义良好的接口和契约联系起来。接口是采用中立的方式进行定义的,它应该独立于实现服务的硬件平台、操作系统和编程语言。这使得构建在各种这样的系统中的服务可以以一种统一和通用的方式进行交互。

SOA与传统服务的区别
传统的Web(HTML/HTTP)技术有效的解决了人与信息系统的交互和沟通问题,极大的促进了B2C模式的发展。WEB服务(XML/SOAP /WSDL)技术则是要有效的解决信息系统之间的交互和沟通问题,促进B2B/EAI/CB2C的发展。SOA则是采用面向服务的商业建模技术和WEB服务技术,实现系统之间的松耦合,实现系统之间的整合与协同。WEB服务和SOA的本质思路在于使得信息系统个体在能够沟通的基础上形成协同工作。

解释下列WebService名词:WSDL、SOAP、UDDI

WSDL是一种 XML 格式,用于将网络服务描述为一组端点,这些端点对包含面向文档信息或面向过程信息的消息进行操作。这种格式首先对操作和消息进行抽象描述,然后将其绑定到具体的网络协议和消息格式上以定义端点。相关的具体端点即组合成为抽象端点(服务)。
SOAP即简单对象访问协议(Simple Object Access Protocol),它是用于交换XML编码信息的轻量级协议。
UDDI 的目的是为电子商务建立标准;UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范,同时也包含一组使企业能将自身提供的Web Service注册,以使别的企业能够发现的访问协议的实现标准。

介绍一下你对SOA的认识

这个问题可以从WHY SOA和SOA面临的挑战入手回答
1. WHY SOA? SOA的好处在哪里?
减低IT成本:重用现有的系统,而且SOA系统本身也可以被后来的应用重用; 减少维护费用,对现有系统造成很少的改动。
增加IT收入:快速的适应新的需求,快速的实现,提高性能,实现云计算 如 Google, Amazon等等
2. SOA面临的挑战有哪些?
更多的系统参与到SOA中,更多的人参与到SOA中,需要更多的交流沟通
在安全控制方面特别是在EAI(enterprise application integration)的MOM(Message Oriented Middleware)中的安全控制更加复杂
需要更高更新的技术参与进来,需要更多的有经验的人员。

主要的开源ESB产品有哪些?各有什么特点?

主要的开源ESB有Mule,Apache ServiceMix,Open ESB, Jboss ESB, Apache Synapse 等等

Mule

它是一个轻量级的消息框架和整合平台,基于EIP(Enterprise Integeration Patterns,由Hohpe和Woolf编写的一本书)而实现的。
Mule的核心组件是UMO(Universal Message Objects,从Mule2.0开始UMO这一概念已经被组件Componse所代替),UMO实现整合逻辑。

Apache ServiceMix

它是JBI规范的一种实现。它包涵了许多JBI组件,这些组件支持多种协议,比如JMS,HTTP,FTP,FILE等。同时也实现了EIP,规则和调度。

Open ESB是由SUN发起,现在作为Java.net的子项目。所有Open ESB的开发人员都来自SUN。
如同Apache ServiceMix一样,Open ESB也实现了JBI规范。Open ESB可运行在由SUN支持的Glassfish应用服务中。同时SUN的Netbeans IDE为Open ESB提供了拖拉式的开发工具,这是其他开源ESB不可匹敌的

Apache Synapse具备一些ESB所必备的功能,但是从本质上而言Synapse更是一个web服务仲裁框架,它是构建在Apache Axis2之上的。Synapse的关注点是路由,转换,消息验证以及基于web服务和xml标准的注册。它支持HTTP, SOAP, SMTP, JMS,FTP ,MTOM/XOPPOP3/IMAP/SMTP 等传输协议,还支持多种web服务规范(WS-*),比如WS-Addressing,WS-Security,WS-Policy以及WS- Reliable Messaging。在它的最新版本1.2中加入了对FIX(Financial Information eXchange,金融信息交换协议 ) 和 Hessian  的支持。同时它还支持多种流行语言,比如Java, JavaScript, Ruby, Groovy等。JBoss ESB是基于JBoss公司的ESB产品Rosetta的。Jboss ESB将JbossMQ作为其消息层,将JBoss rules为其提供路由功能,
将jBPM为其提供服务编排功能。

什么是ESB?请介绍一下ESB?

ESB的全称是Enterprise Service Bus (企业服务总线)。它是一个ielinghuode用于集成各种企业应用即服务的连接基础架构,企业服务总线能够通过简化企业应用及服务之间的链接数量,接口大小以及接口复杂度使企业的面向服务体系SOA更加强大。

Enterprise Service Bus 主要提供一下几方面的功能:

1. 在服务于服务之间或者应用于应用之间路由消息;

2. 在服务请求者与服务提供者之间转换传输协议;

3. 在服务请求者与服务提供者之间转换消息格式;

4. 处理来自于各种已购源的业务事件;

企业服务总线使企业可以更主要的关于企业的核心业务而不用在关注与连接各种应用的IT基础架构,它还可以让企业在增加新的服务及对已有服务进行修改时,可以对原有系统及服务不产生影响或者只有微小的影响。

介绍一下Axis2?

Apache Axis2是一个基于Java的Web Service实现, 它提供了完整的对象模型和模块化的架构。
Axis2可以让你轻易的完成如下工作:
1. 发送SOAP消息
2. 接受和处理SOAP消息
3. 从一个纯Java类生成一个Web Service
4. 使用WSDL来创建服务端和客户端的实现类
5. 非常容易的从一个service来获取WSDL
6. 发送和接受带有附件的SOAP消息
7. 创建和使用REST的Web Service
8. 创建和使用带有WS-Security, WS-ReliableMessaging, WS-Addressing, WS-Coordination和WS-AtomicTransaction的Web Service.
9. 使用Axis2的模块化结构来容易的添加新的支持

SOA的常见陷阱或者误解是什么?

最经常出现的陷阱是开发人员只注意在构建一个SOA解决方案而不是解决一个特定的业务问题,这样就会在不同的IT系统之间造成复杂的,不易管理的和不必要的联系。

如何在SOA中实现松耦合?

实现松耦合的一个策略是使用service interface(如果是SOAP web service的话就是指WSDL)来限制它的依赖性, 对消费者隐藏服务的实现。 实现松耦合需要更好的包装服务和功能以降低对service接口的改变。

top-down和bottom-up这两种实现SOA的流程哪种更鼓励重用和维护?

因为top-down流程是业务驱动的(business-driven), 所以它能实际的拆分业务和IT之间的不同关注点, 提供一个通用的对两个都合适的解决方案。所以在大部分情况下,如果你想在中期和长期提高重用和ROL,top-down都是最合适的

如何定义一个可复用的服务?

可复用的服务是一个自主的, 可复用的, 显式的,无状态的功能。它拥有一定的粒度,可是是一个组合应用和组合服务的一部分。

可复用的服务必须由服务规范(Service Specifications)描述的业务活动所认可。

一个服务的约束,包括安全, QoS, SLA, 使用策略可能被多个运行时契约(Contracts), 多个接口(SOAP web service的WSDL)和多种实现(代码)所定义。

一个可复用的服务需在它的整个生命周期的管理都需要时企业级的。在设计时一直到运行时,它的重用都需要通过规定的流程来保证,而且重用也是需要评估的。

WSDL的操作类型主要有几种?

request-response类型是最常见的操作类型,但是WSDL总共有四种操作类型。

Type

定义

One-way

这个操作会接受消息但是不会返回一个响应

Request-response

这个操作会接受一个请求而且返回一个响应

Solicit-response

这个操作会发送一个请求然后等待响应

Notification

这个操作会发送一个消息而且不等待响应。

介绍一下WSDL Ports

<portType>元素是最重要的WSDL元素。

它用来描述一个web service, web service进行的操作和web service包含的消息。

<portType>元素类似与传统编程语言中的一个功能类。

请介绍一下WSDL的文档结构

WSDL文档的主要元素有:

元素

定义

<types>

web service使用的数据类型

<message>

web service使用的消息

<portType>

web service进行的操作(方法)

<binding>

web service使用的通信协议

请简单介绍一下WSDL

1. WSDL stands for Web Services Description Language, WSDL的全称是Web Service Description Lanaguage.

2. WSDL是XML格式的, WSDL就是一个XML文档。

3. WSDL是用来描述Web Service的。

4. WSDL也用来定位Web Service。

5. WSDL是W3C推荐的。

第三章:J2EE高级软件工程师面试题

                          --------数据库面试题部分

为数据库创建索引都需要注意些什么?

1. 索引能提高速度的关键就是索引所占的空间要比表小得多
2. 注意索引的大小,有一些表可以建成索引组织表
3. 索引的列不要太多,要选择一些selective比较低的列建B-tree索引,选择selective高的列建bitmap索引(在更新比较多的表不不要建bitmap索引)
4. 将selective较低的列放在前面
5. 在更新不多的表上建索引时,可以考虑用compress选择,以节约索引的空间

第一范式(1NF)、第二范式(2NF)和第三范式(3NF)之间的区别是什么?

构造数据库必须遵循一定的规则。在关系数据库中,这种规则就是范式。范式是符合某一种级别的关系模式的集合。关系数据库中的关系必须满足一定的要求,即满足不同的范式。目前关系数据库有六种范式:第一范式(1NF)、第二范式(2NF)、第三范式(3NF)、第四范式(4NF)、第五范式(5NF)和第六范式(6NF)。满足最低要求的范式是第一范式(1NF)。在第一范式的基础上进一步满足更多要求的称为第二范式(2NF),其余范式以次类推。一般说来,数据库只需满足第三范式(3NF)就行了。下面我们举例介绍第一范式(1NF)、第二范式(2NF)和第三范式(3NF)。

3.4.1 第一范式(1NF)
    在任何一个关系数据库中,第一范式(1NF)是对关系模式的基本要求,不满足第一范式(1NF)的数据库就不是关系数据库。
     所谓第一范式(1NF)是指数据库表的每一列都是不可分割的基本数据项,同一列中不能有多个值,即实体中的某个属性不能有多个值或者不能有重复的属性。如果出现重复的属性,就可能需要定义一个新的实体,新的实体由重复的属性构成,新实体与原实体之间为一对多关系。在第一范式(1NF)中表的每一行只包含一个实例的信息。例如,对于图3-2 中的员工信息表,不能将员工信息都放在一列中显示,也不能将其中的两列或多列在一列中显示;员工信息表的每一行只表示一个员工的信息,一个员工的信息在表中只出现一次。简而言之,第一范式就是无重复的列。

3.4.2 第二范式(2NF)
    第二范式(2NF)是在第一范式(1NF)的基础上建立起来的,即满足第二范式(2NF)必须先满足第一范式(1NF)。第二范式(2NF)要求数据库表中的每个实例或行必须可以被惟一地区分。为实现区分通常需要为表加上一个列,以存储各个实例的惟一标识。如
图3-2 员工信息表中加上了员工编号(emp_id)列,因为每个员工的员工编号是惟一的,因此每个员工可以被惟一区分。这个惟一属性列被称为主关键字或主键、主码。
     第二范式(2NF)要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性,如果存在,那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体,新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列,以存储各个实例的惟一标识。简而言之,第二范式就是非主属性非部分依赖于主关键字。

3.4.3 第三范式(3NF)
    满足第三范式(3NF)必须先满足第二范式(2NF)。简而言之,第三范式(3NF)要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。例如,存在一个部门信息表,其中每个部门有部门编号(dept_id)、部门名称、部门简介等信息。那么在图3-2
的员工信息表中列出部门编号后就不能再将部门名称、部门简介等与部门有关的信息再加入员工信息表中。如果不存在部门信息表,则根据第三范式(3NF)也应该构建它,否则就会有大量的数据冗余。简而言之,第三范式就是属性不依赖于其它非主属性。
所谓范式就是符合某一种级别的关系模式的集合。通过分解把属于低级范式的关系模式转换为几个属于高级范式的关系模式的集合。这一过程称为规范化。  
   
  1、   第一范式(1NF):一个关系模式R的所有属性都是不可分的基本数据项。  
  2、   第二范式(2NF):关系模式R属于第一范式,且每个非主属性都完全函数依赖于键码。  
  3、   第三范式(3NF):关系模式R属于第一范式,且每个非主属性都不伟递领带于键码。  
  4、   BC范式(BCNF):关系模式R属于第一范式,且每个属性都不传递依赖于键码。

一组SQL面试题

1. 在表A中有数据
ID    MO
1    Y
2    N
请用一个SELECT 语句写出,如果MO的值为“Y”,返回“YES”,为N返回“NO”
效果如下:
ID    MO
1    YES
2    NO
SELECT ID,MO=CASE
WHEN MO=’Y’ THEN ‘YES’
WHEN MO=’N’ THEN ‘NO’
END
FROM Az
2. 在表A中查询出自动增长列中31到40之间的数据(注意可能不是连续的)
select * from A where id between 31 and 40
3. 有一个表table中有一个自动增长字段ID,如果在存储过程中向这个表插入一条记录后,如何获得新记录的ID.(写出获取新记录ID的函数即可)
CREATE FUNCTION c_currentId()
RETURNS int
AS
BEGIN
declare @lastId int
select @lastId=max(cid) from c
RETURN (@lastId)
END
select tempdb.dbo.c_currentId() as ‘当前C表中最新的编号’
4. having的用法, 是用来做什么的    having用来对group by 分组后的记录进行过滤。
5. sql中的什么函数可以转换为时间     select convert(datetime,’2000/01/01′)    select cast(’2001/02/02′ as datetime)
6. 查询数据放入一张临时表    select * into #A from Test    select * from #A

存储过程的优缺点是什么?

优点:
1.由于应用程序随着时间推移会不断更改,增删功能,T-SQL过程代码会变得更复杂,StoredProcedure为封装此代码提供了一个替换位置。

2.执行计划(存储过程在首次运行时将被编译,这将产生一个执行计划-- 实际上是 Microsoft SQL Server为在存储过程中获取由 T-SQL 指定的结果而必须采取的步骤的记录。)缓存改善性能。
……..但sql server新版本,执行计划已针对所有 T-SQL 批处理进行了缓存,而不管它们是否在存储过程中,所以没比较优势了。

3.存储过程可以用于降低网络流量,存储过程代码直接存储于数据库中,所以不会产生大量T-sql语句的代码流量。

4.使用存储过程使您能够增强对执行计划的重复使用,由此可以通过使用远程过程调用 (RPC) 处理服务器上的存储过程而提高性能。RPC 封装参数和调用服务器端过程的方式使引擎能够轻松地找到匹配的执行计划,并只需插入更新的参数值。

5.可维护性高,更新存储过程通常比更改、测试以及重新部署程序集需要较少的时间和精力。

6.代码精简一致,一个存储过程可以用于应用程序代码的不同位置。

7.更好的版本控制,通过使用 Microsoft Visual SourceSafe 或某个其他源代码控制工具,您可以轻松地恢复到或引用旧版本的存储过程。

8.增强安全性:
a、通过向用户授予对存储过程(而不是基于表)的访问权限,它们可以提供对特定数据的访问;
b、提高代码安全,防止 SQL注入(但未彻底解决,例如,将数据操作语言--DML,附加到输入参数);
c、SqlParameter 类指定存储过程参数的数据类型,作为深层次防御性策略的一部分,可以验证用户提供的值类型(但也不是万无一失,还是应该传递至数据库前得到附加验证)。

缺点:

1.如果更改范围大到需要对输入存储过程的参数进行更改,或者要更改由其返回的数据,则您仍需要更新程序集中的代码以添加参数、更新 GetValue() 调用,等等,这时候估计比较繁琐了。

2.可移植性差

由于存储过程将应用程序绑定到 SQL Server,因此使用存储过程封装业务逻辑将限制应用程序的可移植性。如果应用程序的可移植性在您的环境中非常重要,则将业务逻辑封装在不特定于 RDBMS 的中间层中可能是一个更佳的选择。

如何用SQL语句进行模糊查找?

LIKE条件一般用在指定搜索某字段的时候, 通过”% _” 通配符的作用实现模糊查找功能,通配符可以在前面也可以在后面或前后都有。

搜索以mian开头:
SELECT * FROM teble WHERE title LIKE ‘mian%’

搜索以mian结束:
SELECT * FROM teble WHERE title LIKE ‘%mian’

搜索包含mian:
SELECT * FROM teble WHERE title LIKE ‘%mian%’
注释:%表示0个或多个字符构成的字符串
_表示单个字符

介绍一下内联、左联、右联

一.先看一些最简单的例子

例子

Table A
aid adate
1 a1
2 a2
3 a3

TableB

bid bdate
1 b1
2 b2
4 b4
两个表a,b相连接,要取出id相同的字段
select * from a inner join b on a.aid = b.bid这是仅取出匹配的数据.
此时的取出的是:
1 a1 b1
2 a2 b2

那么left join 指:
select * from a left join b on a.aid = b.bid
首先取出a表中所有数据,然后再加上与a,b匹配的的数据
此时的取出的是:
1 a1 b1
2 a2 b2
3 a3 空字符

同样的也有right join
指的是首先取出b表中所有数据,然后再加上与a,b匹配的的数据
此时的取出的是:
1 a1 b1
2 a2 b2
4 空字符 b4

LEFT JOIN 或 LEFT OUTER JOIN。
左向外联接的结果集包括 LEFT OUTER 子句中指定的左表的所有行,而不仅仅是联接列所匹配的行。如果左表的某行在右表中没有匹配行,则在相关联的结果集行中右表的所有选择列表列均为空值

二. left join/right join/inner join操作演示

表A记录如下:
aID aNum
1 a20050111
2 a20050112
3 a20050113
4 a20050114
5 a20050115

表B记录如下:
bID bName
1 2006032401
2 2006032402
3 2006032403
4 2006032404
8 2006032408

实验如下:
1. left join
sql语句如下:

SELECT * FROM A
LEFT JOIN B
ON A.aID = B.bID
结果如下:
aID aNum bID bName
1 a20050111 1 2006032401
2 a20050112 2 2006032402
3 a20050113 3 2006032403
4 a20050114 4 2006032404
5 a20050115 NULL NULL
(所影响的行数为 5 行)

结果说明:
left join是以A表的记录为基础的,A可以看成左表,B可以看成右表,left join是以左表为准的.
换句话说,左表(A)的记录将会全部表示出来,而右表(B)只会显示符合搜索条件的记录(例子中为: A.aID = B.bID).
B表记录不足的地方均为NULL.

2. right join
sql语句如下:

SELECT * FROM A
RIGHT JOIN B
ON A.aID = B.bID
结果如下:
aID aNum bID bName
1 a20050111 1 2006032401
2 a20050112 2 2006032402
3 a20050113 3 2006032403
4 a20050114 4 2006032404
NULL NULL 8 2006032408
(所影响的行数为 5 行)

结果说明:
仔细观察一下,就会发现,和left join的结果刚好相反,这次是以右表(B)为基础的,A表不足的地方用NULL填充.

3.inner join
sql语句如下:

SELECT * FROM A
INNERJOIN B
ON A.aID = B.bID
结果如下:
aID aNum bID bName
1 a20050111 1 2006032401
2 a20050112 2 2006032402
3 a20050113 3 2006032403
4 a20050114 4 2006032404

结果说明:
很明显,这里只显示出了 A.aID = B.bID的记录.这说明inner join并不以谁为基础,它只显示符合条件的记录.

-----------------[以下为网上的一点资料]------------------
LEFT JOIN操作用于在任何的 FROM 子句中,组合来源表的记录。使用 LEFT JOIN 运算来创建一个左边外部联接。左边外部联接将包含了从第一个(左边)开始的两个表中的全部记录,即使在第二个(右边)表中并没有相符值的记录。

语法:
FROM table1 LEFT JOIN table2 ON table1.field1 compopr table2.field2

说明:
① table1, table2参数用于指定要将记录组合的表的名称。
② field1, field2参数指定被联接的字段的名称。且这些字段必须有相同的数据类型及包含相同类型的数据,但它们不需要有相同的名称。
③ compopr参数指定关系比较运算符:”=”, “<", ">“, “<=", ">=” 或 “<>“。
④ 如果在INNER JOIN操作中要联接包含Memo 数据类型或 OLE Object 数据类型数据的字段,将会发生错误。

说一下mysql, oracle等常见数据库的分页实现方案?

1.Oracle:
select * from ( select row_.*, rownum rownum_ from ( query_SQL ) row_ where rownum =< max) where rownum_ >= min
2.SQL Server:
select top @pagesize * from tablename where id not in (select top @pagesize*(@page-1) id from tablename order by id) order by id

3.MySQL
select * from tablename limit position, counter

4.DB2
select * from (select *,rownumber() as ROW_NEXT from tablename) where ROW_NEXT between min and max

——————————————————————————————–
1.分页方案一:(利用Not In和SELECT TOP分页)效率次之
语句形式:
SELECT TOP 10 * FROM TestTable
WHERE(ID NOT IN (SELECT TOP 20  id FROM  TestTable  ORDERBY  id))   ORDERBYID
SELECT  TOP 页大小 * FROM TestTable
WHERE( ID NOT IN (SELECT  TOP  每页大小-1*待查询页数-1  id  FROM  表 ORDERBY  id)) ORDERBYID
思路:先查询出待查询页之前的全部条数的id,查询ID不在这些ID中的指定数量条数

2.分页方案二:(利用ID大于多少和SELECT TOP分页)效率最高
语句形式:
SELECT  TOP  10 *   FROM  TestTable
WHERE(ID>(SELECT MAX(id) FROM(SELECT TOP20 id  FROM  TestTable ORDERBYid)AS T))ORDERBY ID
SELECT  TOP  页大小* FROM  TestTable
WHERE(ID>(SELECT MAX(id) FROM(SELECT TOP 每页大小*待查询页数-1  id FROM 表  ORDERBY id)AS T)) ORDERBY ID
思路:先获得待查询页的之前全部条数id,获得它们当中最大的ID号,以此最大ID号为标志,查找比这个ID号大的指定条数

3.分页方案三:
SELECT TOP PageSize * FROM(SELECT TOP nPage*PageSize * from YOURTABLE order by id)as a order by id desc
SELECT TOP 每页条数 * FROM (SELECT TOP 待查询页*每页条数) * from YOURTABLE order by id)as a order by id desc
思路:先正排序查询出待查询页之前(包括当前页)的全部条数,然后将其倒排序,取指定条数

几个SQL的面试题

1. 解释一下SQL里面的null
答案:null代表一个unknown的值或者一个不存在的值
2. 如何用SQL判断一个值是不是null?
答案:可以用is null来判断一个值是不是null
3.    所有包含null的计算表达式的返回结果都是null, 这句话正确吗?比如5+ null返回null
答案:正确
4. 所有与null得比较运算都返回unknown正确吗?
答案:正确
5. (unknown or true) = true正确吗?
答案:正确
6. (unknown or false) = unknown正确吗?
答案:正确
7. (unknown or unknown) = unknown正确吗?
答案:正确
8. (true and unknown) = unknown正确吗?
答案:正确
9. (false and unknown) = false正确吗?
答案:正确
10. (unknown and unknown) = unknown正确吗?
答案:正确
11.   (not unknown) = unknown 正确吗?
答案:正确

介绍一下游标?

游标是从数据表中提取出来的数据,以临时表的形式存放在内存中,在游标中有一个数据指针,在初始状态下指向的是首记录,利用fetch语句可以移动该指针,从而对游标中的数据进行各种操作,然后将操作结果写回数据表中。

由 SELECT 语句返回的行集包括所有满足该语句 WHERE 子句中条件的行。由语句所返回的这一完整的行集被称为结果集。应用程序,特别是交互式联机应用程序,并不总能将整个结果集作为一个单元来有效地处理。这些应用程序需要一种机制以便每次处理一行或一部分行。游标就是提供这种机制的结果集扩展。

游标通过以下方式扩展结果处理:

l         允许定位在结果集的特定行。

l         从结果集的当前位置检索一行或多行。

l         支持对结果集中当前位置的行进行数据修改。

l         为由其他用户对显示在结果集中的数据库数据所做的更改提供不同级别的可见性支持。

l         提供脚本、存储过程和触发器中使用的访问结果集中的数据的 Transact-SQL 语句。

存储过程的优点有哪些?

l         更快的执行速度:存储过程只在创造时进行编译,以后每次执行存储过程都不需再重新编译,而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度;

l         与事务的结合,提供更好的解决方案:当对数据库进行复杂操作时(如对多个表进行Update、Insert、Query和Delete时),可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用;

l         支持代码重用:存储过程可以重复使用,可减少数据库开发人员的工作量;

l         安全性高:可设定只有某此用户才具有对指定存储过程的使用权。

介绍一下SQL Server的全文索引?

全文索引可以对存储在SQL Server数据库中的文本数据执行快速检索功能。同LIKE谓词不同,全文索引只对字符模式进行操作,对字和语句执行搜索功能。全文索引对于查询非结构化数据非常有效。一般情况下,可以对char、varchar和nvarchar数据类型的列创建全文索引,同时,还可以对二进制格式的列创建索引,如image和varbinary数据类型列。对于这些二进制数据,无法使用LIKE谓词。

为了对表创建全文索引,表必须包含单个、唯一、非空列。当执行全文检索的时候,SQL Server搜索引擎返回匹配搜索条件的行的键值。一般情况,使用sql server中的全文索引,经过大体4个步骤:

l         安装全文索引服务;

l         为数据表建立全文索引目录;

l         使全文索引与数据表内容同步;

l         使用全文索引进行查询。

SQL Server里面什么样的视图才能创建索引?

在为视图创建索引前,视图本身必须满足以下条件:

l         视图以及视图中引用的所有表都必须在同一数据库中,并具有同一个所有者。

l         索引视图无需包含要供优化器使用的查询中引用的所有表。

l         必须先为视图创建唯一群集索引,然后才可以创建其它索引。

l         创建基表、视图和索引以及修改基表和视图中的数据时,必须正确设置某些 SET 选项(在本文档的后文中讨论)。另外,如果这些 SET 选项正确,查询优化器将不考虑索引视图。

l         视图必须使用架构绑定创建,视图中引用的任何用户定义的函数必须使用 SCHEMABINDING 选项创建。

l         另外,还要求有一定的磁盘空间来存放由索引视图定义的数据。

介绍一下SQL Server里面的索引视图?

复杂报表的场景经常会在数据仓储应用程序中遇到,它在查询过程中会对数据库服务器产生大量请求。当这些查询访问视图时,因为数据库将建立视图结果集所需的逻辑合并到从基本表数据建立完整查询结果集所需的逻辑中,所以性能将会下降。这一操作的开销可能会比较大,尤其当视图涉及到复杂的大量行处理–如大量数据聚合或多表联结时。因为结果集并不永久存放在数据库(标准视图)中,以后对该视图的访问可能导致在每次执行查询时建立结果集的代价。

SQL Server允许为视图创建独特的聚集索引,从而让访问此类视图的查询的性能得到极大地改善。在创建了这样一个索引后,视图将被执行,结果集将被存放在数据库中,存放的方式与带有聚集索引的表的存放方式相同。这就在数据库中有效地实现了查询结果。对于那些在FROM子句中不直接指定视图名的查询,SQL Server查询优化器将使用视图索引。现有查询将受益于从索引视图检索数据而无需重新编写程序原码的高效率。对于某些特定类型的视图,甚至可以获得指数级的性能改善。

如果在视图上创建索引,那么视图中的数据会被立即存储在数据库中,对索引视图进行修改,那么这些修改会立即反映到基础表中。同理,对基础表所进行的数据修改也会反映到索引视图那里。索引的惟一性大大提高了SQL Server 查找那些被修改的数据行。

维护索引视图比维护基础表的索引更为复杂。所以,如果认为值得以因数据修改而增加系统负担为代价来提高数据检索的速度,那么应该在视图上创建索引。

什么是唯一索引?

唯一索引可以确保索引列不包含重复的值。在多列唯一索引的情况下,该索引可以确保索引列中每个值组合都是唯一的。例如,如果在 last_name、first_name 和 middle_initial 列的组合上创建了唯一索引 full_name,则该表中任何两个人都不可以具有相同的全名。

聚集索引和非聚集索引都可以是唯一的。因此,只要列中的数据是唯一的,就可以在同一个表上创建一个唯一的聚集索引和多个唯一的非聚集索引。

只有当唯一性是数据本身的特征时,指定唯一索引才有意义。如果必须实施唯一性以确保数据的完整性,则应在列上创建 UNIQUE 或 PRIMARY KEY 约束,而不要创建唯一索引。例如,如果打算经常查询雇员表(主键为 emp_id)中的社会安全号码 (ssn) 列,并希望确保社会安全号码的唯一性,则在 ssn 列上创建 UNIQUE 约束。如果用户为一个以上的雇员输入了同一个社会安全号码,则会显示错误。

什么是聚集索引和非聚集索引? 分布介绍一下

(1)非聚集索引

非聚集索引与课本中的索引类似。数据存储在一个地方,索引存储在另一个地方,索引带有指针指向数据的存储位置。索引中的项目按索引键值的顺序存储,而表中的信息按另一种顺序存储(这可以由聚集索引规定)。如果在表中未创建聚集索引,则无法保证这些行具有任何特定的顺序。

典型的桌面数据库使用的是非聚集索引。在这类索引中,索引键值是有序的,而每个索引节点所指向的数据行是无序的。一个SQL Server表最多可以拥有255个非聚集索引。

非聚集索引与聚集索引一样有 B-树结构,但是有两个重大差别:

l         数据行不按非聚集索引键的顺序排序和存储。

l         非聚集索引的叶层不包含数据页。

相反,叶节点包含索引行。每个索引行包含非聚集键值以及一个或多个行定位器,这些行定位器指向有该键值的数据行(如果索引不唯一,则可能是多行)。非聚集索引可以在有聚集索引的表、堆集或索引视图上定义。在 SQL Server中,非聚集索引中的行定位器有两种形式:

l         如果表是堆集(没有聚集索引),行定位器就是指向行的指针。该指针用文件标识符 (ID)、页码和页上的行数生成。整个指针称为行 ID。

l         如果表是堆集(没有聚集索引),行定位器就是指向行的指针。该指针用文件标识符 (ID)、页码和页上的行数生成。整个指针称为行 ID。

由于非聚集索引将聚集索引键作为其行指针存储,因此使聚集索引键尽可能小很重要。如果表还有非聚集索引,请不要选择大的列作为聚集索引的键。

在创建非聚集索引之前,应先了解您的数据是如何被访问的。可考虑将非聚集索引用于:

l         包含大量非重复值的列,如姓氏和名字的组合(如果聚集索引用于其它列)。如果只有很少的非重复值,如只有 1 和 0,则大多数查询将不使用索引,因为此时表扫描通常更有效。

l         不返回大型结果集的查询。

l         返回精确匹配的查询的搜索条件(WHERE 子句)中经常使用的列。

l         经常需要联接和分组的决策支持系统应用程序。应在联接和分组操作中使用的列上创建多个非聚集索引,在任何外键列上创建一个聚集索引。

l         在特定的查询中覆盖一个表中的所有列。这将完全消除对表或聚集索引的访问。

(2)聚集索引

聚集索引确定表中数据的物理顺序。聚集索引类似于电话簿,后者按姓氏排列数据。由于聚集索引规定数据在表中的物理存储顺序,因此一个表只能包含一个聚集索引。但该索引可以包含多个列(组合索引),就像电话簿按姓氏和名字进行组织一样。

聚集索引在系统数据库表sysindexes 内有一行,其 indid = 1。数据链内的页和其内的行按聚集索引键值排序。所有插入都在所插入行中的键值与排序顺序相匹配时执行。

SQL Server将索引组织为B-树。索引内的每一页包含一个页首,页首后面跟着索引行。每个索引行都包含一个键值以及一个指向较低级页或数据行的指针。索引的每个页称为索引节点。B-树的顶端节点称为根节点。索引的底层节点称为叶节点。每级索引中的页链接在双向链接列表中。在聚集索引内数据页组成叶节点。根和叶之间的任何索引级统称为中间级。

对于聚集索引,sysindexes.root 指向它的顶端。SQL Server 沿着聚集索引浏览以找到聚集索引键对应的行。为找到键的范围,SQL Server 浏览索引以找到这个范围的起始键值,然后用向前或向后指针扫描数据页。为找到数据页链的首页,SQL Server 从索引的根节点开始沿最左边的指针进行扫描.

聚集索引对于那些经常要搜索范围值的列特别有效。使用聚集索引找到包含第一个值的行后,便可以确保包含后续索引值的行在物理相邻。例如,如果应用程序执行的一个查询经常检索某一日期范围内的记录,则使用聚集索引可以迅速找到包含开始日期的行,然后检索表中所有相邻的行,直到到达结束日期。这样有助于提高此类查询的性能。同样,如果对从表中检索的数据进行排序时经常要用到某一列,则可以将该表在该列上聚集(物理排序),避免每次查询该列时都进行排序,从而节省成本。

对于聚集索引,人们往往有一些错误的认识。其中,最常见的错误有:

l         聚集索引会降低insert操作的速度,因为必须要向后移动一半的数据来为新插入的行腾出空间。这种认识是错误的,因为可以利用填充因子控制填充的百分比,从而在索引页上为新插入的数据保留空间。如果索引页填满了,SQL Server将会进行页拆分,在这种情况下只有第一个页才会受到影响。

l         在使用标识列的主键上创建聚集索引是一种好的设计方法,它可以使对表的操作达到最快速度。这种认识是错误的,它浪费了创建其它更有效的聚集索引的机会。并且,使用这种方法会把每个新插入的记录行都存储到表尾部的同一个的数据页中,这将导致数据库的热点和锁争用。笔者曾经见过采用这种方法设计的数据库,对于每一个新订单,客户服务人员都不得不等待数分钟来加以确认。

l         聚集索引是具有魔力的。如果哪个查询的速度不够快,那么就在该列上创建聚集索引,对于表的操作速度一定会得到提高。这种认识也是错误的,聚集索引只是比非聚集索引稍稍快了那么一点点。因为在每个表上只能创建一个聚集索引,所以它也是一种宝贵的性能资源,只有在那些经常作为条件查询一组记录行的列上才应该建立聚集索引。

在创建聚集索引之前,应先了解数据是如何被访问的。可考虑将聚集索引用于:

l         包含大量非重复值的列。

l         使用下列运算符返回一个范围值的查询:BETWEEN、>、>=、< 和 <=。

l         被连续访问的列。

l         返回大型结果集的查询。

l         经常被使用联接或 GROUP BY 子句的查询访问的列;一般来说,这些是外键列。对 ORDER BY 或 GROUP BY 子句中指定的列进行索引,可以使 SQL Server 不必对数据进行排序,因为这些行已经排序。这样可以提高查询性能。

l         OLTP 类型的应用程序,这些程序要求进行非常快速的单行查找(一般通过主键)。应在主键上创建聚集索引。

注意,聚集索引不适用于:

l         频繁更改的列,这将导致整行移动(因为 SQL Server 必须按物理顺序保留行中的数据值)。这一点要特别注意,因为在大数据量事务处理系统中数据是易失的。

l         宽键,来自聚集索引的键值由所有非聚集索引作为查找键使用,因此存储在每个非聚集索引的叶条目内。

SQL Server提供的3种恢复模型都是什么? 有什么区别?

SQL Server提供了3种恢复模型,分别是:

l         简单恢复 ,允许将数据库恢复到最新的备份。

l         完全恢复,允许将数据库恢复到故障点状态。

l         大容量日志记录恢复,允许大容量日志记录操作。

这些模型中的每个都是针对不同的性能、磁盘和磁带空间以及保护数据丢失的需要。例如,当选择恢复模型时,必须考虑下列业务要求之间的权衡:

l         大规模操作的性能(如创建索引或大容量装载)。

l         数据丢失表现(如已提交的事务丢失)。

l         事务日志空间损耗

l         备份和恢复过程的简化。

根据正在执行的操作,可以有多个适合的模型。选择了恢复模型后,设计所需的备份和恢复过程。表6提供了三种恢复模型的优点和含义的概述。

表 6备份模型之间的比较

恢复模型

优点

工作损失表现

能否恢复到即时点?

简单

允许高性能大容量复制操作。

收回日志空间以使空间要求最小。

必须重做自最新的数据库或差异备份后所发生的更改。

可以恢复到任何备份的结尾处。随后必须重做更改。

完全

数据文件丢失或损坏不会导致工作损失。

可以恢复到任意即时点(例如,应用程序或用户错误之前)。

正常情况下没有。

如果日志损坏,则必须重做自最新的日志备份后所发生的更改。

可以恢复到任何即时点。

大容量日志记录的

允许高性能大容量复制操作。大容量操作使用最少的日志空间。

如果日志损坏,或者自最新的日志备份后发生了大容量操作,则必须重做自上次备份后所做的更改。否则不丢失任何工作。

可以恢复到任何备份的结尾处。随后必须重做更改。

简单恢复所需的管理最少。在简单恢复模型中,数据只能恢复到最新的完整数据库备份或差异备份的状态。不使用事务日志备份,而使用最小事务日志空间。一旦不再需要日志空间从服务器故障中恢复,日志空间便可重新使用。与完整模型或大容量日志记录模型相比,简单恢复模型更容易管理,但如果数据文件损坏,则数据损失表现会更高。

完全恢复和大容量日志记录恢复模型为数据提供了最大的保护性。这些模型依靠事务日志提供完全的可恢复性,并防止最大范围的故障情形所造成的工作损失。完全恢复模型提供最大的灵活性,可将数据库恢复到更早的即时点。

大容量日志记录模型为某些大规模操作(如创建索引或大容量复制)提供了更高的性能和更低的日志空间损耗。不过这将牺牲时点恢复的某些灵活性。很多数据库都要经历大容量装载或索引创建的阶段,因此可能希望在大容量日志记录模型和完全恢复模型之间进行切换。

SQL Server的固定数据库角色都有哪些?对应的服务器权限有哪些?

固定服务器角色

对应的服务器级权限

bulkadmin

授予的权限: ADMINISTER BULK OPERATIONS

dbcreator

授予的权限: CREATE DATABASE

diskadmin

授予的权限: ALTER RESOURCES

processadmin

授予的权限: ALTER SERVER STATE

processadmin

授予的权限: ALTER ANY CONNECTION

securityadmin

授予的权限: ALTER ANY LOGIN

serveradmin

授予的权限: ALTER SETTINGS

serveradmin

授予的权限: SHUTDOWN

serveradmin

授予的权限: CREATE ENDPOINT

serveradmin

授予的权限: ALTER SERVER STATE

serveradmin

授予的权限: ALTER ANY ENDPOINT

serveradmin

授予的权限: ALTER RESOURCES

setupadmin

授予的权限: ALTER ANY LINKED SERVER

sysadmin

带GRANT 选项授予的权限:CONTROL SERVER

 

 

在SQL Server中创建数据库主要有那种方式?

在SQL Server中创建数据库主要有两种方法,第一种是在SQL Server Management Studio中使用向导创建数据库;第二种是执行Transact-SQL语句创建数据库。下面我们分别进行介绍。

(1)使用SQL Server Management Studio创建数据库

在SQL Server Management Studio中,可以使用向导创建数据库,步骤如下:

1.  打开SQL Server Management Studio。

2.     右击“数据库”对象,在弹出式菜单中选择“新建数据库”菜单项,打开“新建数据库”对话框

3.  在“常规”页,可以定义数据库的名称为EAMS、数据库文件、数据库的所有者、排序规则、恢复模型,以及是否使用全文索引。

4.    在“选项”页,可以定义数据库的一些选项,包括自动选项、游标选项、混杂选项、恢复选项、行级版本选项和状态选项

5.    在“文件组”页,显示文件组和文件的统计信息,同时还可以设置是否采用默认值

6.  在“扩展属性”页,可以定义数据库的一些扩展属性,如图5所示。

7.  当完成各个选项的定义之后,单击【OK】按钮,SQL Server数据库引擎会创建所定义的数据库。

(2)使用Transact-SQL创建数据库

Transact-SQL提供了创建数据库的语句:CREATE DATABASE,其语法格式如下:

CREATE DATABASE database_name

[ ON

[ <filespec> [ ,...n ] ]

[ , <filegroup> [ ,...n ] ]

]

[

[ LOG ON { <filespec> [ ,...n ] } ]

[ COLLATE collation_name ]

[ FOR { ATTACH [ WITH <service_broker_option> ]

| ATTACH_REBUILD_LOG } ]

[ WITH <external_access_option> ]

]

[;]

<filespec> ::=

[ PRIMARY ]

(

[ NAME = logical_file_name , ]

FILENAME = ‘os_file_name’

[ , SIZE = size [ KB | MB | GB | TB ] ]

[ , MAXSIZE = { max_size [ KB | MB | GB | TB ] | UNLIMITED } ]

[ , FILEGROWTH = growth_increment [ KB | MB | % ] ]

) [ ,...n ]

<filegroup> ::=

FILEGROUP filegroup_name

<filespec> [ ,...n ]

<external_access_option> ::=

DB_CHAINING { ON | OFF }

| TRUSTWORTHY { ON | OFF }

<service_broker_option> ::=

ENABLE_BROKER

| NEW_BROKER

| ERROR_BROKER_CONVERSATIONS

Create a Database Snapshot

CREATE DATABASE database_snapshot_name

ON

(

NAME = logical_file_name,

FILENAME = ‘os_file_name’

) [ ,...n ]

AS SNAPSHOT OF source_database_name

[;]

参数说明如下:

l         database_name,新数据库的名称。数据库名称在服务器中必须唯一,并且符合标识符的规则。database_name 最多可以包含 128 个字符,除非没有为日志指定逻辑名。如果没有指定日志文件的逻辑名,则SQL Server会通过向 database_name 追加后缀来生成逻辑名。该操作要求 database_name 在 123 个字符之内,以便生成的日志文件逻辑名少于 128 个字符。

l         ON,指定显式定义用来存储数据库数据部分的磁盘文件(数据文件)。该关键字后跟以逗号分隔的 <filespec> 项列表,<filespec> 项用以定义主文件组的数据文件。主文件组的文件列表后可跟以逗号分隔的 <filegroup> 项列表(可选),<filegroup> 项用以定义用户文件组及其文件。

l         N,占位符,表示可以为新数据库指定多个文件。

l         LOG ON,指定显式定义用来存储数据库日志的磁盘文件(日志文件)。该关键字后跟以逗号分隔的 <filespec> 项列表,<filespec> 项用以定义日志文件。如果没有指定 LOG ON,将自动创建一个日志文件,该文件使用系统生成的名称,大小为数据库中所有数据文件总大小的 25%。

l         FOR LOAD,支持该子句是为了与早期版本的 SQL Server 兼容。数据库在打开 dbo use only 数据库选项的情况下创建,并且将其状态设置为正在装载。

l         FOR ATTACH,指定从现有的一组操作系统文件中附加数据库。必须有指定第一个主文件的 <filespec> 条目。至于其它 <filespec> 条目,只需要与第一次创建数据库或上一次附加数据库时路径不同的文件的那些条目。必须为这些文件指定 <filespec> 条目。附加的数据库必须使用与 SQL Server 相同的代码页和排序次序创建。应使用 sp_attach_db 系统存储过程,而不要直接使用 CREATE DATABASE FOR ATTACH。只有必须指定 16 个以上的 <filespec> 项目时,才需要使用 CREATE DATABASE FOR ATTACH。 如果将数据库附加到的服务器不是该数据库从中分离的服务器,并且启用了分离的数据库以进行复制,则应该运行 sp_removedbreplication 从数据库删除复制。

l         collation_name,指定数据库的默认排序规则。排序规则名称既可以是 Windows 排序规则名称,也可以是 SQL 排序规则名称。如果没有指定排序规则,则将 SQL Server 实例的默认排序规则指派为数据库的排序规则。

l         PRIMARY,指定关联的 <filespec> 列表定义主文件。主文件组包含所有数据库系统表。还包含所有未指派给用户文件组的对象。主文件组的第一个 <filespec> 条目成为主文件,该文件包含数据库的逻辑起点及其系统表。一个数据库只能有一个主文件。如果没有指定 PRIMARY,那么 CREATE DATABASE 语句中列出的第一个文件将成为主文件。

l         NAME,为由 <filespec> 定义的文件指定逻辑名称。如果指定了 FOR ATTACH,则不需要指定 NAME 参数。

l         logical_file_name,用来在创建数据库后执行的 Transact-SQL 语句中引用文件的名称。logical_file_name 在数据库中必须唯一,并且符合标识符的规则。该名称可以是字符或 Unicode 常量,也可以是常规标识符或定界标识符。

l         FILENAME,为 <filespec> 定义的文件指定操作系统文件名。

l         os_file_name,操作系统创建 <filespec> 定义的物理文件时使用的路径名和文件名。os_file_name 中的路径必须指定 SQL Server 实例上的目录。os_file_name 不能指定压缩文件系统中的目录。如果文件在原始分区上创建,则 os_file_name 必须只指定现有原始分区的驱动器字母。每个原始分区上只能创建一个文件。原始分区上的文件不会自动增长;因此,os_file_name 指定原始分区时,不需要指定 MAXSIZE 和 FILEGROWTH 参数。

l         SIZE,指定 <filespec> 中定义的文件的大小。如果主文件的 <filespec> 中没有提供 SIZE 参数,那么 SQL Server 将使用 model 数据库中的主文件大小。如果次要文件或日志文件的 <filespec> 中没有指定 SIZE 参数,则 SQL Server 将使文件大小为 1 MB。

l         Size,<filespec> 中定义的文件的初始大小。可以使用千字节 (KB)、兆字节 (MB)、千兆字节 (GB) 或兆兆字节 (TB) 后缀。默认值为 MB。指定一个整数,不要包含小数位。size 的最小值为 512 KB。如果没有指定 size,则默认值为 1 MB。为主文件指定的大小至少应与 model 数据库的主文件大小相同。

l         MAXSIZE,指定 <filespec> 中定义的文件可以增长到的最大大小。

l         max_size,<filespec> 中定义的文件可以增长到的最大大小。可以使用千字节 (KB)、兆字节 (MB)、千兆字节 (GB) 或兆兆字节 (TB) 后缀。默认值为 MB。指定一个整数,不要包含小数位。如果没有指定 max_size,那么文件将增长到磁盘变满为止。

l         UNLIMITED,指定 <filespec> 中定义的文件将增长到磁盘变满为止。

l         FILEGROWTH,指定 <filespec> 中定义的文件的增长增量。文件的 FILEGROWTH 设置不能超过 MAXSIZE 设置。

l         growth_increment,每次需要新的空间时为文件添加的空间大小。指定一个整数,不要包含小数位。0 值表示不增长。该值可以 MB、KB、GB、TB 或百分比 (%) 为单位指定。如果未在数量后面指定 MB、KB 或 %,则默认值为 MB。如果指定 %,则增量大小为发生增长时文件大小的指定百分比。如果没有指定 FILEGROWTH,则默认值为 10%,最小值为 64 KB。指定的大小舍入为最接近的 64 KB 的倍数。

l         <filegroup>,控制文件组的属性。文件组不能在数据库快照上定义。

l         FILEGROUP,定义文件组的逻辑名。

l         filegroup_name,表示在创建数据库之后,在Transact-SQL语句中引用文件组的名称。filegroup_name在数据库中必须唯一,不能是系统提供的名称,如PRIMARY和PRIMARY_LOG。名称必须同标识符的规则保持一致。

l         default,定义文件组为特定文件组类型的默认数据库文件组。

l         DB_CHAINING { ON | OFF },当设置为ON的时候,数据库可以为交叉数据库所有者关系链中的源或者目标。当设置为OFF的时候,数据库不能参与交叉数据库所有者关系链,对于用户数据库,可以修改这个选项,但是不能修改系统数据库的该选项。默认值为OFF。

l         TRUSTWORTHY { ON | OFF },当设置为ON的时候,数据库模块(如视图、用户自定义函数或者存储过程)允许访问数据库外的资源。当设置为OFF的时候,数据库模块不能访问数据库之外的资源。默认值为OFF。

l         <service_broker_options> ,当授予FOR ATTACH子句的时候,才能设置Service Broker选项。

l         ENABLE_BROKER,定义数据库是否启用Service Broker。

l         NEW_BROKER,在sys数据库中和恢复数据库中创建新的service_broker_guid。

l         ERROR_BROKER_CONVERSATIONS,终止所有发生错误的会话。

l         database_snapshot_name,定义新数据库的快照名。

l         ON (NAME =logical_file_name, FILENAME =’os_file_name’) [ ,... n ] ,对于创建一个数据库快照,在源数据库中定义文件列表。

l         AS SNAPSHOT OF source_database_name,定义创建的数据库为一个源数据库的数据库快照。

几道数据库的面试题或笔试题 难度适中

1.张表,学生表S,课程C,学生课程表SC,学生可以选修多门课程,一门课程可以被多个学生选修,通过SC表关联;(SQL)
1)写出建表语句;
答:建表语句如下(mysql数据库):
create table s(id integer primary key, name varchar(20));
create table c(id integer primary key, name varchar(20));
create table sc(
sid integer references s(id),
cid integer references c(id),
primary key(sid,cid)
);
2)写出SQL语句,查询选修了所有选修课程的学生;
答:SQL语句如下:
select stu.id, stu.name from s stu
where (select count(*) from sc where sid=stu.id) =
(select count(*) from c);
3)写出SQL语句,查询选修了至少5门以上的课程的学生。
答:SQL语句如下:
select stu.id, stu.name from s stu
where (select count(*) from sc where sid=stu.id)>=5;

2.数据库表(Test)结构如下:(SQL)
IDNAMEAGEMANAGER(所属主管人ID)
106A30104
109B19104
104C20111
107D35109
112E25120
119F45NULL
要求:列出所有年龄比所属主管年龄大的人的ID和名字?
答:SQL语句如下:
select employee.name from test employee where employee.age>
(select manager.age from test manager where manager.id=employee.manager);

3.有3个表(15分钟):(SQL)
Student 学生表 (学号,姓名,性别,年龄,组织部门)
Course 课程表 (编号,课程名称)
Sc 选课表 (学号,课程编号,成绩)
表结构如下:

1)写一个SQL语句,查询选修了’计算机原理’的学生学号和姓名(3分钟)
答:SQL语句如下:
select stu.sno, stu.sname from Student stu
where (select count(*) from sc where sno=stu.sno and cno =
(select cno from Course where cname=’计算机原理’)) != 0;
2)写一个SQL语句,查询’周星驰’同学选修了的课程名字(3分钟)
答:SQL语句如下:
select cname from Course where cno in (select cno from sc where sno=(select sno from Student where sname=’周星驰’));
3)写一个SQL语句,查询选修了5门课程的学生学号和姓名(9分钟)
答:SQL语句如下:
select stu.sno, stu.sname from student stu
where (select count(*) from sc where sno=stu.sno) = 5;

ORACLE面试测试题目

1.    解释FUNCTION,PROCEDURE和PACKAGE区别
答:function 和procedure是PL/SQL代码的集合,通常为了完成一个任务。procedure 不需要返回任何值而function将返回一个值在另一方面,Package是为了完成一个商业功能的一组function和procedure的集合。

2.    取某个序列的当前值的PL/SQL语句怎么写?
答:SELECT 序列名.CURRVAL  FROM  DUAL;

3.    说明ORACLE数据库实例与ORACLE用户的关系?
答:实例可以包含多个用户,一个用户只能在一个实例下

4.    创建数据库时,自动建立的tablespace名称?
答:SYSTEM tablespace

5.    创建用户时,需要赋予新用户什么权限才能使它连上数据库?
答:CONNECT

6.    IMPORT和SQL*LOADER这2个工具的不同点?
答:这两个ORACLE工具都是用来将数据导入数据库的。
区别是:IMPORT工具只能处理由另一个ORACLE工具EXPORT生成的数据。而SQL*LOADER可以导入不同的ASCII格式的数据源。

7.解释冷备份和热备份的不同点以及各自的优点?
答:热备份针对归档模式的数据库,在数据库仍旧处于工作状态时进行备份。而冷备份指在数据库关闭后,进行备份,适用于所有模式的数据库。热备份的优点在于当备份时,数据库仍旧可以被使用并且可以将数据库恢复到任意一个时间点。冷备份的优点在于它的备份和恢复操作相当简单,并且由于冷备份的数据库可以工作在非归档模式下,数据库性能会比归档模式稍好。(因为不必将archive log写入硬盘)

8.比较truncate和delete命令?
答:两者都可以用来删除表中所有的记录。区别在于:truncate是DDL(data defining language数据定义语言),它移动HWK,不需要rollback segment(处理事务回滚操作)而Delete是DML(data manufacturing language数据操作语言)操作,需要rollback segment(处理事务回滚操作)且花费较长时间。

9.给出数据的相关约束类型?
答:主键约束,外键约束,非空约束,唯一约束,检查约束。

10.说明索引的类型与作用?
答:索引类型上分为聚集索引,非聚集索引其作用是加快查询速度。

11.解释归档和非归档模式之间的不同和它们各自的优缺点
答:归档模式是指你可以备份所有的数据库 transactions并恢复到任意一个时间点。非归档模式则相反,不能恢复到任意一个时间点。但是非归档模式可以带来数据库性能上的少许提高。

12.解释$ORACLE_HOME和$ORACLE_BASE的区别?
答:ORACLE_BASE是oracle的根目录,ORACLE_HOME是oracle产品的目录。

13.获取某个字符字段的最后3个字符的函数是什么?
答:select substr (字段,(length(字段)-3)) from 表

14.取当前系统时间点日期(不包括年月)的SQL写法是怎样的?
答:Select substr (to_char(sysdate,’YYYYMMDDh24hh:MM:SS’),5) from dual;

15.返回大于等于N的最小整数值?
答:select ceil(N) from dual;

16.将根据字符查询转换后结果,规则为:’A’转换为’男’,’B’转换为’女’,其他字符转换为’未知’,请用一个SQL语句写出。
答:select decode(字符,’A’,’男’,’B’,’女’,’未知’) from dual;

17.如何搜索出前N条记录?
答:select * from 表 where  Rownum <= N;

18.如何搜索出第N~M条记录?
答:select * from 表 where Rownum <= M
Minus
select * from 表 where Rownum <= N;

19.有一个数据表(TEST),字段如下:
ID      number
PARENT_ID      number
NAME      Varchar(20)
请使用PL/SQL来按父子层次关系查询出该表的所有数据
答:Select * from test a, test b Where a.parent_id = b.id;

20.怎样用SQL语句实现查找一列中的第N大值?
答:select * from (select * from 表 order by 列名 Desc) where Rownum <= N
Minus
select * from (select * from 表 order by 列名 Desc) where Rownum <= N-1;

腾讯公司的一个sql题

小小+霸霸+王王=小霸王 
小=?,霸=?,王=? 
用sql求证

参考答案:

declare @data int,@i int,@j int,@l int 
set @data=100 
while (@data<=999) 
begin 
   set @i=@data/100 
   set @j=@data/10 % 10 
   set @l=@data % 10 
   if((@i+@j+@l)*11=@data) 
   begin 
      Select @data data,@i i,@j j,@l l 
      break 
   end 
   set @data=@data+1 
end; 
分析: 
II+JJ+LL=IJL 
I*10+I +J*10+J+L*10+L   =   I*100+J*10+L 
(I+J+L)*11

1、  一套Oracle面试题笔试题

完成下列操作,写出相应的SQL语句

  1. 创建表空间neuspace,数据文件命名为neudata.dbf,存放在d:\data目录下,文件大小为200MB,设为自动增长,增量5MB,文件最大为500MB。(8分)

答:create tablespace neuspace datafile ‘d:\data\neudata.dbf’ size 200m auto extend on next 5m maxsize 500m;

2. 假设表空间neuspace已用尽500MB空间,现要求增加一个数据文件,存放在e:\appdata目录下,文件名为appneudata,大小为500MB,不自动增长。(5分)

答:alter tablespace neuspace add datafile ‘e:\appdata\appneudata.dbf’ size 500m;

3. 以系统管理员身份登录,创建账号tom,设置tom的默认表空间为neuspace。为tom分配connect和resource系统角色,获取基本的系统权限。然后为tom分配对用户scott的表emp的select权限和对SALARY, MGR属性的update权限。(8分)

答:create user tom identified by jack default tablespace neuspace;

Grant connect, resource to tom;

Grant select, update(salary, mgr) on scott.emp to tom;

4. 按如下要求创建表class和student。(15分)

属性

类型(长度)

默认值

约束

含义

CLASSNO

数值 (2)

主键

班级编号

CNAME

变长字符 (10)

非空

班级名称

 

属性

类型(长度)

默认值

约束

含义

STUNO

数值 (8)

主键

学号

SNAME

变长字符 (12)

非空

姓名

SEX

字符 (2)

性别

BIRTHDAY

日期

生日

EMAIL

变长字符 (20)

唯一

电子邮件

SCORE

数值 (5, 2)

检查

成绩

CLASSNO

数值 (2)

外键,关联到表CLASS的CLASSNO主键

班级编号

答:create table class

(classno number(2) constraint class_classno_pk primary key,

cname varchar2(10) not null);

create table student

(stuno number(8) constraint student_stuno_pk primary key,

sname varchar2(12) not null,

sex char(2) default ‘男’,

birthday date,

email varchar2(20) constraint student_email_uk unique,

score number(5,2) constraint student_score_ck check(score>=0 and score<=100),

classno number(2) constraint student_classno_fk references class(classno)

);

5. 在表student的SNAME属性上创建索引student_sname_idx(5分)

答:create index student_sname_idx on student(sname);

6. 创建序列stuseq,要求初值为20050001,增量为1,最大值为20059999。(6分)

答:create sequence stuseq increment by 1 start with 20050001 maxvalue 20059999 nocache nocycle;

7. 向表student中插入如下2行。(5分)

STUNO

SNAME

SEX

BIRTHDAY

EMAIL

SCORE

CLASSNO

从stuseq取值

tom

1979-2-3 14:30:25

tom@163.net

89.50

1

从stuseq取值

jerry

默认值

2

答:insert into student values(stuseq.nextval, ’tom’, ’男’, to_date(‘1979-2-3

14:30:25’, ’yyyy-mm-dd fmhh24:mi:ss’), ’tom@163.net’, 89.50, 1);

insert into student (stuno, sname, classno) values(stuseq.nextval, ’jerry’, 2);

8. 修改表student的数据,将所有一班的学生成绩加10分。(4分)

答:update student set score=score+10 where classno=1;

9. 删除表student的数据,将所有3班出生日期小于1981年5月12日的记录删除。(4分)

答:delete from student where classno=3 and birthday > ’12-5月-81’;

10. 完成以下SQL语句。(40分)

(1) 按班级升序排序,成绩降序排序,查询student表的所有记录。

答:select * from student order by classno, score desc;

(2) 查询student表中所有二班的成绩大于85.50分且出生日期大于1982-10-31日的男生的记录。

答:select * from student where classno=2 and score>85.50 and birthday < ’31-10月-82’ and sex=’男’;

(3) 查询student表中所有三班成绩为空的学生记录。

答:select * from student where classno=3 and score is null;

(4) 表student与class联合查询,要求查询所有学生的学号,姓名,成绩,班级名称。(使用oracle与SQL 99两种格式)

答:select s.stuno, s.sname, s.score, c.cname from student s, class c where s.classno=c.classno;

(5) 按班级编号分组统计每个班的人数,最高分,最低分,平均分,并按平均分降序排序。

答:select classno, count(*), max(score), min(score), avg(score) from student group by classno order by avg(score) desc;

(6) 查询一班学生记录中所有成绩高于本班学生平均分的记录。

答:select * from student where classno=1 and score > (select avg(score) from student where classno=1);

(7) 统计二班学生中所有成绩大于所有班级平均分的人数。

答:select count(*) from student where classno=2 and score > all (select avg(socre) from student group by classno);

(8) 查询平均分最高的班级编号与分数。

答:select classno, avg(score) from student group by classno having avg(score) = (select max(avg(score)) from student group by classno);

(9) 查询所有学生记录中成绩前十名的学生的学号、姓名、成绩、班级编号。

答:select stuno, sname, score, classno from (select * from student order by score desc) where rownum<=10;

(10) 创建视图stuvu,要求视图中包含student表中所有一班学生的stuno, sname, score, classno四个属性,并具有with check option限制。

答:create view stuvu

as

select stuno, sname,score,classno from student where classno=1 with check option;

2、  一道Oracle笔试题

表结构说明:
create table employee(
id number(10) not null, — 员工工号
salary number(10,2) default 0 not null, — 薪水
name varchar2(24) not null — 姓名
);
1.创建序列seq_employee,该序列每次取的时候它会自动增加,从1开始计数,不设最大值,并且一直累加,不循环。(10分)
2.写一个PL/SQL块,插入表user.employee中100条数据。插入该表中字段id用序列seq_employee实现,薪水和姓名字段可以任意填写。(15分)

 

6.写一个匿名语句块,用于执行函数f_employee,并打印执行该函数的结果。(8分)
7.创建存储过程p_create_emp,用于判断表employee是否存在,如果存在则删除该表。(15分)
8.写一个匿名语句块,用于执行存储过程p_create_emp。(7分)
答案如下:
SQL> create table employee(
2 id number(10) not null, — 员工工号
3 salary number(10,2) default 0 not null, — 薪水
4 name varchar2(24) not null — 姓名
5 );
表已创建。
—第一题答案:
SQL> Create sequence seq_employee increment by 1 start with 1 nomaxvalue nocycle;
序列已创建。
—第二题答案:
SQL> declare i number;
2 begin
3 for i in 1 .. 100
4 loop
5 insert into employee
6 values(seq_employee.nextval,1950+i,’王明’||to_char(i));
7 commit;
8 end loop;
9 end;
10 /
PL/SQL 过程已成功完成。
SQL> select * from employee where rownum<11;
ID SALARY NAME
———- ———- ————————
1 1951 王明1
2 1952 王明2
3 1953 王明3
4 1954 王明4
5 1955 王明5
6 1956 王明6
7 1957 王明7
8 1958 王明8
9 1959 王明9
10 1960 王明10
已选择10行。
3.写一个语句块,在语句块中定义一个显式游标,按id升序排列,打印表employee中前十条数据。(15分)
——-第三题答案:
SQL> declare
2 cursor c is select id,salary,name from(select * from employee order by id) where rownum<11;
3 v_record c%rowtype;
4 begin
5 open c;
6 loop
7 fetch c into v_record;
8 exit when c%notfound;
9 dbms_output.put_line(to_char(v_record.id)||’,'||to_char(v_record.salary)||’,'||v_record.name);
10 end loop;
11 close c;
12 end;
13 /
1,1951,王明1
2,1952,王明2
3,1953,王明3
4,1954,王明4
5,1955,王明5
6,1956,王明6
7,1957,王明7
8,1958,王明8
9,1959,王明9
10,1960,王明10
PL/SQL 过程已成功完成。
4.创建存储过程p_employee,输入员工薪水范围,返回员工工号、姓名、薪水结果集,结果集按员工薪水升序排列。(15分)
——-第四题答案
SQL> create or replace procedure p_employee
2 (iminsalary in number,
3 imaxsalary in number)
4 is
5 begin
6 for x in(select id,salary,name from(select * from employee where salary between iminsalary and imaxsalary) order by salary)
7 loop
8 dbms_output.put_line(to_char(x.id)||to_char(x.salary)||x.name);
9 end loop;
10 end;
11 /
过程已创建。
SQL> exec p_employee(2000,2007);
502000王明50
512001王明51
522002王明52
532003王明53
542004王明54
552005王明55
562006王明56
572007王明57
PL/SQL 过程已成功完成。
5.创建函数f_employee实现更新员工薪水的功能,将薪水低于2000且姓wang的员工薪水加5%,其他不变,更新成功则返回0,否则返回1。(15分)
———第五题答案
SQL> create or replace function f_employee return number
is
begin
update employee set salary=salary+salary*0.05 where salary<2000 and name like ‘王%’;
commit;
if sql%rowcount=0 then
return 1;
else
return 0;
end if;
end;
/
函数已创建。
—–第六题答案
SQL> declare a number;
2 begin
3 a:=f_employee();
4 dbms_output.put_line(to_char(a));
5 end;
6 /
0
PL/SQL 过程已成功完成。
SQL> select * from employee where salary<2000 and name like ‘王%’;
未选定行
SQL> select * from employee where rownum<50;
ID SALARY NAME
———- ———- ————————
1 2048.55 王明1
2 2049.6 王明2
3 2050.65 王明3
4 2051.7 王明4
5 2052.75 王明5
6 2053.8 王明6
7 2054.85 王明7
8 2055.9 王明8
9 2056.95 王明9
10 2058 王明10
11 2059.05 王明11
ID SALARY NAME
———- ———- ————————
12 2060.1 王明12
13 2061.15 王明13
14 2062.2 王明14
15 2063.25 王明15
16 2064.3 王明16
17 2065.35 王明17
18 2066.4 王明18
19 2067.45 王明19
20 2068.5 王明20
21 2069.55 王明21
22 2070.6 王明22
ID SALARY NAME
———- ———- ————————
23 2071.65 王明23
24 2072.7 王明24
25 2073.75 王明25
26 2074.8 王明26
27 2075.85 王明27
28 2076.9 王明28
29 2077.95 王明29
30 2079 王明30
31 2080.05 王明31
32 2081.1 王明32
33 2082.15 王明33
ID SALARY NAME
———- ———- ————————
34 2083.2 王明34
35 2084.25 王明35
36 2085.3 王明36
37 2086.35 王明37
38 2087.4 王明38
39 2088.45 王明39
40 2089.5 王明40
41 2090.55 王明41
42 2091.6 王明42
43 2092.65 王明43
44 2093.7 王明44
ID SALARY NAME
———- ———- ————————
45 2094.75 王明45
46 2095.8 王明46
47 2096.85 王明47
48 2097.9 王明48
49 2098.95 王明49
已选择49行。
—–第七题答案
SQL> create or replace procedure p_create_emp
2 is
3 v_count number;
4 begin
5 select count(*) into v_count from user_tables where table_name=’EMPLOYEE’;
6 if v_count=0 then
7 return;
8 else
9 execute immediate ‘drop table employee’;
10 end if;
11 end;
12 /
过程已创建。

———第八题答案
SQL> exec p_create_emp;
PL/SQL 过程已成功完成。
SQL> select * from employee;
select * from employee
*
ERROR 位于第 1 行:
ORA-00942: 表或视图不存在

如何查询Oracle数据库中已经创建的索引?

查询数据字典user_indexes和user_ind_columns

例子:

SQL> SELECT ic.index_name, ic.column_name,

2         ic.column_position col_pos,ix.uniqueness

3  FROM    user_indexes ix, user_ind_columns ic

4  WHERE   ic.index_name = ix.index_name

5  AND ic.table_name = ‘S_EMP’;

注意: 数据字典里存放的字符都是大写的.

哪些情况下不应该使用索引?

1. 表很小的情况下,没有必要使用索引

2. 不经常在Where后使用的比较字段

3. 如果表数据需要频繁修改,不建议使用索引

4. 如果查询返回记录很多,不建议使用索引

5. 如果where后含IS NULL /IS NOT NULL/ like ‘%输入符%’等条件,不建议使用索引。

SQL里面如何插入自动增长序列号字段?

INSERT时如果要用到从1开始自动增长的数字做唯一关键字, 应该先建立一个序列号.

CREATE SEQUENCE 序列号的名称 (最好是表名+序列号标记) INCREMENT BY 1 START WITH 1 MAXVALUE 99999 NOCYCLE NOCACHE;

其中最大的值按字段的长度来定,比如定义的自动增长的序列NUMBER(6) , 最大值为999999

INSERT 语句插入这个字段值为: 序列号的名称.NEXTVAL

例子: SQL> insert into s_dept(id, name, region_id) values (s_dept_id.nextval, ‘finance’, 2);

1 row created.

只有运行了序列号的名称. nextval后序列号的名称. currval 才有效才有值.

不用游标的SQL语句有哪些?

1. 说明性语句
2. 数据定义语句
3. 数据控制语句
4. 查询结果为单记录的SELECT语句
5. 非CURRENT形式的UPDATE语句
6. 非CURRENT形式的DELETE语句
7. INSERT语句
所有的说明性语句及数据定义与控制语句都不需要使用游标,他们是嵌入式SQL中最简单的一类语句,不需要返回结果数据,也不需要使用主变量。 在主语言中嵌入说明性语句及数据定义与控制语句,只要给语句加上前缀EXEC SQL 和预计结束符即可。
INSERT语句也不需要使用游标,但通常需要使用主变量
SELECT语句,UPDATE语句,DELETE语句则要复杂些。

必须要使用游标的SQL语句有那些?

必须要使用游标的SQL语句有:
1. 查询结果为多结果的SELECT语句
2. CURRENT形式的UPDATE语句
3. CURRENT形式的DELETE语句

查询优化的一般准则有哪些?

1. 选择运算应尽可能先做。这是优化策略中最重要最基本的一条
2. 在执行连接前对关系适当的预处理,方法有两种:在连接属性上建立索引和对关系排序,然后执行连接,第一种称为索引连接方法,第二种称为排序合并连接方法
3. 把投影运算和选择运算同时进行。
4. 把投影同其前或者其后的双目运算结合起来,没有必要为了去掉某些字段而扫描一下关系
5. 把某些选择同它前面要执行的笛卡尔积结合起来成为一个连接运算,连接特别是等值连接运算要比同样关系上的笛卡尔积节省很多时间
6. 找出公共子表达式,先计算出公共子表达式的值才参与运算。

ORACLE二十问

1. Oracle安裝完成后的初始口令? 

   internal/oracle
   sys/change_on_install
    system/manager
    scott/tiger
    sysman/oem_temp  

  2. ORACLE9IAS WEB CACHE的初始默认用户和密码?  

   administrator/administrator 

  3. oracle 8.0.5怎么创建数据库?  

   用orainst。如果有motif界面,可以用orainst /m 

  4. oracle 8.1.7怎么创建数据库?

   dbassist 

  5. oracle 9i 怎么创建数据库? 

   dbca  

  6. oracle中的裸设备指的是什么?  

   裸设备就是绕过文件系统直接访问的储存空间 

  7. oracle如何区分 64-bit/32bit 版本??? 

  $ sqlplus ‘/ AS SYSDBA’
  SQL*Plus: Release 9.0.1.0.0 – Production on Mon Jul 14 17:01:09 2003
  (c) Copyright 2001 Oracle Corporation. All rights reserved.
  Connected to:
  Oracle9i Enterprise Edition Release 9.0.1.0.0 – Production
  With the Partitioning option
  JServer Release 9.0.1.0.0 – Production
  SQL> select * from v$version;
  BANNER
  Oracle9i Enterprise Edition Release 9.0.1.0.0 – Production
  PL/SQL Release 9.0.1.0.0 – Production
  CORE 9.0.1.0.0 Production
  TNS for Solaris: Version 9.0.1.0.0 – Production
  NLSRTL Version 9.0.1.0.0 – Production
  SQL>  

  8. SVRMGR什么意思? 

  svrmgrl,Server Manager.

  9i下没有,已经改为用SQLPLUS了

  sqlplus /nolog
  变为归档日志型的 

  9. 请问如何分辨某个用户是从哪台机器登陆ORACLE的?

  SELECT machine , terminal FROM V$SESSION;  

  10. 用什么语句查询字段呢? 

  desc table_name 可以查询表的结构
  select field_name,… from … 可以查询字段的值
  select * from all_tables where table_name like ‘%’
  select * from all_tab_columns where table_name=’??’  

  11. 怎样得到触发器、过程、函数的创建脚本? 

  desc user_source
  user_triggers   

  12. 怎样计算一个表占用的空间的大小? 

select owner,table_name,
  NUM_ROWS,
  BLOCKS*AAA/1024/1024 “Size M”,
  EMPTY_BLOCKS,
  LAST_ANALYZED
  from dba_tables
  where table_name=’XXX’;
  Here: AAA is the value of db_block_size ;
  XXX is the table name you want to check 

 14. 如何查看系统被锁的事务时间?
  select * from v$locked_object ;

  15. 如何以archivelog的方式运行oracle。
  init.ora
  log_archive_start = true
  RESTART DATABASE
  16. 怎么获取有哪些用户在使用数据库
  select username from v$session;

  17. 数据表中的字段最大数是多少?

  表或视图中的最大列数为 1000  

  18. 怎样查得数据库的SID ?

  select name from v$database;

  也可以直接查看 init.ora文件

  19. 如何在Oracle服务器上通过SQLPLUS查看本机IP地址 ?

  select sys_context(’userenv’,'ip_address’) from dual;

  如果是登陆本机数据库,只能返回127.0.0.1,呵呵  

  20. unix 下怎么调整数据库的时间?

  su -root

  date -u 08010000

 

如何高效率的查找一个月以内的数据?

进行时间比较要尽量避免用sysdate. 比如:如果使用select * from eventtable where eventdate>sysdate-30进行查找,当数据量小的时候看不出来,数据量大一些就会发现执行很慢,但日期型字 段上也是有索引的,为什么会慢呢? 原来是Oracle在进行查找的时候不断地去取sysdate这个不断变化的值,而不是我们想象中的一次产生一个条件语句然后进行查找。为了加快速度,我 们可以先把当天的日期取出来,然后转成字符串后再用如下语句查,select * from eventtable where eventdate > to_date(’2001-12-1′,’yyyy-mm-dd’)。速度相差几十倍。

Oracle怎样计算一个表占用的空间的大小?

可以使用一下语句来进行计算:

select owner ,
table_name,
NUM_ROWS,
BLOCKS*AAA/1024/1024 “Size M”,
EMPTY_BLOCKS,
LAST_ANALYZED
from dba_tables
where table_name= XXX ;
AAA 是指 db_block_size的值 ;
XXX 是你要查询的表名

如何在Oracle中查看各个表、表空间占用空间的大小?

使用以下语句查看当前用户每个表占用空间的大小:
Select Segment_Name,Sum(bytes)/1024/1024 From User_Extents Group By Segment_Name

使用一下语句查看每个表空间占用空间的大小:
Select Tablespace_Name,Sum(bytes)/1024/1024 From Dba_Segments Group By Tablespace_Name

介绍一下Oracle的操作符优化?

IN :

IN写出来的SQL比较容易写及清晰易懂但是性能总是比较低的,从ORACLE执行的步骤来分析用IN的SQL与不用IN的SQL有以下区别:

ORACLE 试图将IN转换成多个表的连接,如果转换不成功会先执行IN里面的子查询,再查询外层的表记录,如果转换成功,则直接采用多个表的连接方式查询。所以用 IN的SQL至少多了一个转换的过程。一般的SQL都可以转换成功,但对于含有分组统计等方面的SQL就不能转换了。

推荐方法:在业务密集的SQL当中尽量不要采用IN操作符。

NOT IN:

不推荐使用,因为NOT IN不能应用表的索引。

推荐方案:用NOT EXISTS 或(外连接+判断为空)

<> 操作符(不等于)

不等于操作符不会用到索引的,对它的处理只会产生全表扫描。

推荐方案:用其它相同功能的操作运算代替,如 a<>0 改为 a>0 or a<0  a<>’’ 改为 a>’’

IS NULL 或IS NOT NULL操作(判断字段是否为空)

判断字段是否为空一般不会应用索引,因为B树索引是不索引空值的。

推荐方案:

用其它相同功能的操作运算代替,如 a is not null 改为 a>0 或a>’’等。

不允许字段为空,而用一个缺省值代替空值,如业扩申请中状态字段不允许为空,缺省为申请。

建立位图索引(有分区的表不能建,位图索引比较难控制,如字段值太多索引会使性能下降,多人更新操作会增加数据块锁的现象)。

> 及 < 操作符(大于或小于操作符)

大于或小于操作符一般不用调整,因为它有索引就会采用索引查找,但有的情况下可以对它进行优化,如一个表有100万记录,一个数值型字段A, 30万记录的A=0,30万记录的A=1,39万记录的A=2,1万记录的A=3。那么执行A>2与A>=3的效果就有很大的区别了,因为 A>2时ORACLE会先找出为2的记录索引再进行比较,而A>=3时ORACLE则直接找到=3的记录索引。

LIKE:

LIKE 操作符可以应用通配符查询,里面的通配符组合可能达到几乎是任意的查询,但是如果用得不好则会产生性能上的问题,如LIKE ‘%5400%’ 这种查询不会引用索引,而LIKE ‘X5400%’则会引用范围索引。一个实际例子:用YW_YHJBQK表中营业编号后面的户标识号可来查询营业编号 YY_BH LIKE ‘%5400%’ 这个条件会产生全表扫描,如果改成YY_BH LIKE ’X5400%’ OR YY_BH LIKE ’B5400%’ 则会利用YY_BH的索引进行两个范围的查询,性能肯定大大提高。

Oracle如何查询登陆客户端的机器名?

可以用一下语句查询登陆客户端的机器名:

select machine, terminal from V$SESSION

如何提高MySql的安全性?

1.如果MYSQL客户端和服务器端的连接需要跨越并通过不可信任的网络,那么需要使用ssh隧道来加密该连接的通信。

2.使用set password语句来修改用户的密码,先“mysql -u root”登陆数据库系统,然后“mysql> update mysql.user set password=password(’newpwd’)”,最后执行“flush privileges”就可以了。

3.Mysql需要提防的攻击有,防偷听、篡改、回放、拒绝服务等,不涉及可用性和容错方面。对所有的连接、查询、其他操作使用基于acl即访问控制列表的安全措施来完成。也有一些对ssl连接的支持。

4.设置除了root用户外的其他任何用户不允许访问mysql主数据库中的user表;

加密后存放在user表中的加密后的用户密码一旦泄露,其他人可以随意用该用户名/密码相应的数据库;

5.使用grant和revoke语句来进行用户访问控制的工作;

6.不要使用明文密码,而是使用md5()和sha1()等单向的哈系函数来设置密码;

7.不要选用字典中的字来做密码;

8.采用防火墙可以去掉50%的外部危险,让数据库系统躲在防火墙后面工作,或放置在dmz区域中;

9.从因特网上用nmap来扫描3306端口,也可用telnet server_host 3306的方法测试,不允许从非信任网络中访问数据库服务器的3306号tcp端口,需要在防火墙或路由器上做设定;

10.为了防止被恶意传入非法参数,例如where id=234,别人却输入where id=234 or 1=1导致全部显示,所以在web的表单中使用”或”"来用字符串,在动态url中加入%22代表双引号、%23代表井号、%27代表单引号;传递未检查过的值给mysql数据库是非常危险的;

11.在传递数据给mysql时检查一下大小;

12.应用程序需要连接到数据库应该使用一般的用户帐号,开放少数必要的权限给该用户;

$page_devide$

13.在各编程接口(c c++ php perl java jdbc等)中使用特定‘逃脱字符’函数;

在因特网上使用mysql数据库时一定少用传输明文的数据,而用ssl和ssh的加密方式数据来传输;

14.学会使用tcpdump和strings工具来查看传输数据的安全性,例如tcpdump -l -i eth0 -w -src or dst port 3306 strings。以普通用户来启动mysql数据库服务;

15.不使用到表的联结符号,选用的参数 –skip-symbolic-links;

16.确信在mysql目录中只有启动数据库服务的用户才可以对文件有读和写的权限;

17.不许将process或super权限付给非管理用户,该mysqladmin processlist可以列举出当前执行的查询文本;super权限可用于切断客户端连接、改变服务器运行参数状态、控制拷贝复制数据库的服务器;

18.file权限不付给管理员以外的用户,防止出现load data ‘/etc/passwd’到表中再用select 显示出来的问题;

19.如果不相信dns服务公司的服务,可以在主机名称允许表中只设置ip数字地址;

20.使用max_user_connections变量来使mysqld服务进程,对一个指定帐户限定连接数;

21.grant语句也支持资源控制选项;

22.启动mysqld服务进程的安全选项开关,–local-infile=0或1 若是0则客户端程序就无法使用local load data了,赋权的一个例子grant insert(user) on mysql.user to ‘user_name’@'host_name’;若使用–skip-grant-tables系统将对任何用户的访问不做任何访问控制,但可以用 mysqladmin flush-privileges或mysqladmin reload来开启访问控制;默认情况是show databases语句对所有用户开放,可以用–skip-show-databases来关闭掉。

23.碰到error 1045(28000) access denied for user ‘root’@'localhost’ (using password:no)错误时,你需要重新设置密码,具体方法是:先用–skip-grant-tables参数启动mysqld,然后执行 mysql -u root mysql,mysql>update user set password=password(’newpassword’) where user=’root’;mysql>flush privileges;,最后重新启动mysql就可以了。

什么是ddl dml和dcl?

DDL :数据定义语言,用于定义和管理 SQL 数据库中的所有对象的语言
1.CREATE – to create objects in the database   创建数据库对象
2.ALTER – alters the structure of the database   修改数据库对象
3.DROP – delete objects from the database   删除数据库对象
4.TRUNCATE – remove all records from a table, including all spaces allocated for the records are removed
TRUNCATE TABLE [Table Name]。
下面是对Truncate语句在MSSQLServer2000中用法和原理的说明:
Truncate table 表名 速度快,而且效率高,因为:
TRUNCATE TABLE 在功能上与不带 WHERE 子句的 DELETE 语句相同:二者均删除表中的全部行。但 TRUNCATE TABLE 比 DELETE 速度快,且使用的系统和事务日志资源少。
DELETE 语句每次删除一行,并在事务日志中为所删除的每行记录一项。TRUNCATE TABLE 通过释放存储表数据所用的数据页来删除数据,并且只在事务日志中记录页的释放。
TRUNCATE TABLE 删除表中的所有行,但表结构及其列、约束、索引等保持不变。新行标识所用的计数值重置为该列的种子。如果想保留标识计数值,请改用 DELETE。如果要删除表定义及其数据,请使用 DROP TABLE 语句。
对于由 FOREIGN KEY 约束引用的表,不能使用 TRUNCATE TABLE,而应使用不带 WHERE 子句的 DELETE 语句。由于 TRUNCATE TABLE 不记录在日志中,所以它不能激活触发器。
TRUNCATE TABLE 不能用于参与了索引视图的表。
5.COMMENT – add comments to the data dictionary 注释
6.GRANT – gives user’s access privileges to database 授权
7.REVOKE – withdraw access privileges given with the GRANT command   收回已经授予的权限

DML:数据操作语言,SQL中处理数据等操作统称为数据操纵语言
1.SELECT – retrieve data from the a database           查询数据
2.INSERT – insert data into a table                    添加数据
3.UPDATE – updates existing data within a table    更新数据
4.DELETE – deletes all records from a table, the space for the records remain   删除
5.CALL – call a PL/SQL or Java subprogram
6.EXPLAIN PLAN – explain access path to data
Oracle RDBMS执行每一条SQL语句,都必须经过Oracle优化器的评估。所以,了解优化器是如何选择(搜索)路径以及索引是如何被使用的,对优化SQL语句有很大的帮助。Explain可以用来迅速方便地查出对于给定SQL语句中的查询数据是如何得到的即搜索路径(我们通常称为Access Path)。从而使我们选择最优的查询方式达到最大的优化效果。
7.LOCK TABLE – control concurrency 锁,用于控制并发

DCL:数据控制语言,用来授予或回收访问数据库的某种特权,并控制数据库操纵事务发生的时间及效果,对数据库实行监视等
COMMIT – save work done 提交
SAVEPOINT – identify a point in a transaction to which you can later roll back 保存点
ROLLBACK – restore database to original since the last COMMIT   回滚
SET TRANSACTION – Change transaction options like what rollback segment to use   设置当前事务的特性,它对后面的事务没有影响.

什么是数据库的约束?

数据库约束是防止非法记录的规则, 约束保存在数据字典(data dictionary)中, 约束可以被定义在列级或者表级。

Oracle中包括一下集中约束:

1. Not Null – 明确一列数据不能包含null值

2. Unique – 强制所有数据行不能有重复值

3. Primary Key – 每一行数据的唯一标示

4. Foreign Key – 强制一列数据与引用表的外键约束关系

5. Check – 检查,明确规定一个必须为true的condition

Oracle数据库架构中包括几层?每层都有什么元素?

Oracle数据库包括一个逻辑层和物理层,物理层包括Oracle磁盘上的文件, 逻辑层用来映射数据和物理层的文件。

逻辑层包括一下元素:

一个或者多个表空间。

数据库Schema: 包括表,集群,索引,视图,存储过程,数据库触发器和sequences.

介绍一下SQL中union, intersect 和 minus

Union用来返回多个查询的结果的总和去掉重复的结果

语法:
SELECT column1, column2 FROM tablename1
UNION
SELECT column1, column2 FROM tablename2;

Intersect 用来返回多个查询中共同的结果,intersect会忽略null值

语法:

SELECT column1, column2 FROM tablename1
INTERSECT
SELECT column1, column2 FROM tablename2;

MUNUS返回出现在第一个查询结果中但是不出现在第二个查询结果的结果集。

语法:

SELECT column1, column2 FROM tablename1
MINUS
SELECT column1, column2 FROM tablename2;

主键(Primary Key)约束和唯一性(UNIQUE)约束有什么区别?

一个表只能由一个主键,一个表可以有很多个唯一键(UNIQUE Key)

主键不允许有null值,UNIQUE允许null值

Oracle中delete, truncate 和 drop的区别?

Delete命令用来删除表的全部或者一部分数据行,执行delete之后,用户需要提交(commmit)或者回滚(rollback) transaction 来执行删除或者撤销删除, delete命令会触发这个表上所有的delete触发器。

Truncate删除表中的所有数据, 这个操作不能回滚,也不会触发这个表上的触发器,TRUNCATE比delete更快,占用的空间更小。

Drop命令从数据库中删除表, 所有的数据行,索引和权限也会被删除,所有的DML触发器也不会被触发,这个命令也不能回滚。

rowid和rownum有什么不同?

RowId是一个数据库内部的概念,表示表的一行,用来快速的访问某行数据

Rownum是结果集的一个功能, 例如select * from Student where rownum = 2 就是得到结果集的第二行。

视图的作用是什么?

数据库视图的作用只要有:

1. 数据库视图隐藏了数据的复杂性。

2. 数据库视图有利于控制用户对表中某些列的访问。

3. 数据库视图使用户查询变得简单。

视图是一个虚拟表,其内容由查询定义。同真实的表一样,视图包含一系列带有名称的列和行数据。但是,视图并不在数据库中以存储的数据值集形式存在。行和列数据来自由定义视图的查询所引用的表,并且在引用视图时动态生成。

对其中所引用的基础表来说,视图的作用类似于筛选。定义视图的筛选可以来自当前或其它数据库的一个或多个表,或者其它视图。分布式查询也可用于定义使用多个异类源数据的视图。如果有几台不同的服务器分别存储组织中不同地区的数据,而您需要将这些服务器上相似结构的数据组合起来,这种方式就很有用。

通过视图进行查询没有任何限制,通过它们进行数据修改时的限制也很少。

什么是Oracle的同义词(synonym)? 如何创建synonym?

同义词是相当于别名,是为了简化一些表名或者数据对象。 当我们以一个用户登陆而要去访问另一个用户创建的数据对象时,我们需要使用用户名.对象名的方法来使用,这样造成对象名难记,麻烦,使用同义词可以解决这个问题。

假定我们现在以system的身份的登陆进去,我们需要访问scott用户下面的一个表emp;

常规的写法是:select * from scott.emp;

现在我们可以先建立一个同义词:
create synonym my_syn for scott.emp;

然后我们这样来访问这个表了:
select * from my_syn;

什么是数据库锁?Oracle中都有哪些类型的锁?

锁是用来在多个用户同时访问同一个表的时候保护数据的。 它是Oracle的一种并发控制技术。锁使数据库最大并发的情况下保证数据的完整性。 Oracle会在需要的时候自动的提供锁的功能。

锁的种类:

共享锁: 这个锁是数据在被viewed的时候放置的。

排他锁: 这种锁在Insert, Update, Delete命令执行的时候放置的,每一条记录同一时间只能有一个排他锁。

触发器(trigger)的功能都有哪些?写出一个触发器的例子

触发器是数据库中由一个时间触发的特殊的存储过程,他不是由程序条用也不是手工启动的。触发器的执行可以由对一个表的insert,delete, update等操作来触发,触发器经常用于加强数据的完整性约束和业务规则等等。

触发器的功能主要有一下六种:

1、 允许/限制对表的修改

2、 自动生成派生列,比如自增字段

3、 强制数据一致性

4、 提供审计和日志记录

5、 防止无效的事务处理

6、 启用复杂的业务逻辑

Create table foo(a number);
Create trigger biud_foo
Before insert or update or delete
On foo
Begin
If user not in (‘DONNY’) then
Raise_application_error(-20001, ‘You don’t have access to modify this table.’);
End if;
End;

如何杀掉ORACLE里面长期没有释放的锁?

如果一个数据库insert update delete操作很长时间没有反应,就可能出现了没有正常释放的锁。

可以用以下SQL语句杀掉没有正常释放的锁:

alter system kill session ’sid,serial#’;

如何查看当前ORACLE数据库里面锁的情况?

查看数据库锁的情况必须要有DBA权限,可以使用一下SQL 语句:

         select object_id,session_id,locked_mode from v$locked_object;

         select t2.username,t2.sid,t2.serial#,t2.logon_time

         from v$locked_object t1,v$session t2

         where t1.session_id=t2.sid order by t2.logon_time;

长时间出现的锁可能是没有正常释放的锁。

Oracle的锁有几种模式?

Oracle里面的锁共有一下几种模式:

0: none

1:  null 空

2:Row-S 行共享(Row Share RS): 共享表锁

3:Row-X 行专用(RX): 用于行数据的修改

4:Share 共享锁(S): 阻止其他DML操作

5:S/Row-X 共享行专用(SRX): 阻止其他事务操作

6:exclusive 专用(X): 独立访问使用

以上可以看出,数字越大的锁影响的操作越多,锁的级别越高。

一般的查询语句是小于2的锁,如select * from *

select … from … for update 是2的锁,这时候返回集的数据行都将处于行级(Row-X)独占式锁定,其他对象只能对这些数据进行查询,而不能进行更新或者select for update操作。

insert/update/delete是3的锁, 在这些操作没有commit之前插入同样的记录会没有反应,因为3的锁必须要等到前一个3的锁执行释放掉以后才能继续。 创建索引的时候也会产生3,4级别的锁。

locked_mod为2,3,4的锁,不影响DML(insert,delete,update,select)操作,但是DDL(alter,drop)等修改表结构的操作会提示ora-00054错误。

当有主外键约束时执行update/delete操作可能会产生4,5的锁。

DDL语句时是6的锁。

 

 

第四章:J2EE高级软件工程师面试题

                         -----程序设计题部分

 

常用排序算法


package com.sort;

import java.util.Random;

public class No1Maopao {
    public static void main(String[] args) {
        Random rd = new Random();
//生成随即数组
        int [] src = new int[10];
        for(int i=0;i<10;i++){
            src[i]=rd.nextInt(100);
        }
//排序前打印数组所有元素
        for(int i:src)
            System.out.println(i);
        System.out.println("---------------可爱的分割线-------------------");
        src = sort(src);
//排序后打印数组所有元素
        for(int i:src)
            System.out.println(i);
    }

    public static int[] sort(int [] src){
        for (int i = 0; i < src.length; i++) {
            for(int j=i;j<src.length;j++){
                if(src[j]<src[i]){
                    int temp = src[j];
                    src[j]=src[i];
                    src[i]=temp;
                }
            }
        }
        return src;
    }
}
二、选择排序:
package com.sort;

import java.util.Random;

public class No2XuanZhe {
    public static void main(String[] args) {
        Random rd = new Random();
        int[] src = new int[10];
        for (int i = 0; i < 10; i++) {
            src[i] = rd.nextInt(100);
        }
        for (int i : src)
            System.out.println(i);
        System.out.println("---------------可爱的分割线-------------------");
        src = sort(src);
        for (int i : src)
            System.out.println(i);
    }

    public static int[] sort(int[] src) {
        int min;
        for (int i = 0; i < src.length; i++) {
            min = src[i];
            for (int j = i + 1; j < src.length; j++) {
                if (src[j] < min) {
                    min = src[j];
                    int temp = src[i];
                    src[i] = src[j];
                    src[j] = temp;
                }
            }
        }
        return src;
    }
}
三、插入排序:
package com.sort;

import java.util.Random;

public class No3ChaRu {
    public static void main(String[] args) {
        Random rd = new Random();
        int[] src = new int[10];
        for (int i = 0; i < 10; i++) {
            src[i] = rd.nextInt(100);
        }
        for (int i : src)
            System.out.println(i);
        System.out.println("---------------可爱的分割线-------------------");
        src = sort(src);
        for (int i : src)
            System.out.println(i);
    }

    public static int[] sort(int[] src) {
        int in, out;
        for (in = 1; in < src.length; in++) {
            int temp = src[in];
            out = in;
            while (out > 0 && src[out - 1] >= temp) {
                src[out] = src[out - 1];
                --out;
            }
            src[out] = temp;
        }
        return src;
    }
}
四、希尔排序:
package com.sort;

import java.util.Random;

public class No4Xier {
    public static void main(String[] args) {
        Random rd = new Random();
        int[] src = new int[10];
        for (int i = 0; i < 10; i++) {
            src[i] = rd.nextInt(100);
        }
        for (int i : src)
            System.out.println(i);
        System.out.println("---------------可爱的分割线-------------------");
        src = sort(src);
        for (int i : src)
            System.out.println(i);
    }

    public static int[] sort(int[] src) {
        int len = src.length;
        int temp, i, j;
        int h = 1;
        while (h <= len / 3)
            h = h * 3 + 1;
        while (h > 0) {
            for (i = h; i < len; i++) {
                temp = src[i];
                j = i;
                while (j > h - 1 && src[j - h] >= temp) {
                    src[j] = src[j - h];
                    j -= h;
                }
                src[j] = temp;
            }
            h = (h - 1) / 3;
        }
        return src;
    }
}
五、快速排序:
public class No5Kuaisu {

    public static void quickSort(int[] array) {
        quickSort(array, 0, array.length - 1);
    }

    private static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int p = partition(array, low, high);
            quickSort(array, low, p - 1);
            quickSort(array, p + 1, high);
        }

    }

    private static int partition(int[] array, int low, int high) {
        int s = array[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (array[j] < s) {
                i++;
                swap(array, i, j);
            }
        }
        swap(array, ++i, high);
        return i;
    }

    private static void swap(int[] array, int i, int j) {
        int temp;
        temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void main(String[] args) {
        Random rd = new Random();
        int[] src = new int[10];
        for (int i = 0; i < 10; i++) {
            src[i] = rd.nextInt(100);
        }
        for (int i : src)
            System.out.println(i);
        System.out.println("---------------可爱的分割线-------------------");
        quickSort(src);
        for (int i : src)
            System.out.println(i);
        System.out.println("---------------可爱的分割线-------------------");
    }
}

常见算法题目

本题的splitStringByComma(String )方法纯属多余,可以用String的split方法一句话代替,且可读性也更强,下面的一段话源自JDK1.6API,StringTokenizer类已不再提倡使用,保留仅为旧代码。

StringTokenizer 是出于兼容性的原因而被保留的遗留类(虽然在新代码中并不鼓励使用它)。建议所有寻求此功能的人使用 String 的 split 方法或 java.util.regex 包。

import java.util.*;

public class bycomma{

    public static String[] splitStringByComma(String source){

       if(source==null||source.trim().equals(""))     

           return null;  

      StringTokenizer commaToker = new StringTokenizer(source,",");

      String[] result = new String[commaToker.countTokens()];  

       int i=0;  

       while(commaToker.hasMoreTokens()){  

            result[i] = commaToker.nextToken();  

            i++;  

        }  

       return result;

    }

    public static void main(String args[]){

        String[] s = splitStringByComma("5,8,7,4,3,9,1");

         int[] ii = new int[s.length];

         for(int i = 0; i<ii.length;i++){

             ii[i] =Integer.parseInt(s[i]);

            }   

        Arrays.sort(ii);    

        //asc   

        for(int i=0;i<ii.length;i++ ){

          System.out.println(ii[i]);   

         }

       //desc    

        for(int i=(s.length-1);i>=0;i--){

          System.out.println(ii[i]);    

       }            

    }

}

2.编写一个截取字符串的函数,输入为一个字符串和字节数,输出为按字节截取的字符串。 但是要保证汉字不被截半个,如"我ABC"4,应该截为"我AB",输入"我ABC汉DEF",6,应该输出为"我ABC"而不是"我ABC+汉的半个"。

代码:

public static boolean isLetter(char c){

int k=0X80;

return c/k==0?true:false;

 

}

public static int lengths(String strSrc){

if (strSrc==null){

return 0;

}

int len=0;

char[] strChar=strSrc.toCharArray();

for (int i=0;i<strChar.length;i++){

len++;

if (!isLetter(strChar[i])) len++;

}

return len;

}

 

public static String subString(String origin,int len){

if (origin==null || origin.equals("")|| len<1){

return "";

}

if (len>lengths(origin)){

return origin;

}

byte[] strByte=new byte[len];

System.arraycopy(origin.getBytes(),0,strByte,0,len);

int count=0;

for (int i=0;i<len;i++){

int value=(int)strByte[i];

if (value<0) count++;

}

if (count % 2 !=0){

//len=(len==1)?++len:--len;

--len;

}

return new String(strByte,0,len);

}

public static void main(String[] args) {

System.out.println(""+ subString("我ABC汉DEF",6));

}

3、排序都有哪几种方法?请列举。用JAVA实现一个快速排序。

排序的方法有:插入排序(直接插入排序、希尔排序),交换排序(冒泡排序、快速排序),选择排序(直接选择排序、堆排序),归并排序,分配排序(箱排序、基数排序)

快速排序的伪代码。

/ /使用快速排序方法对a[ 0 :n- 1 ]排序从a[ 0 :n- 1 ]中选择一个元素作为m I d d l e,该元素为支点把余下的元素分割为两段left 和r I g h t,使得l e f t中的元素都小于等于支点,而right 中的元素都大于等于支点递归地使用快速排序方法对left 进行排序递归地使用快速排序方法对right 进行排序所得结果为l e f t + m I d d l e + r I g h t

//以下为java程序实现的快速排序算法:

public static void sort(int[] data) {

quickSort(data,0,data.length-1);

}

public static void quickSort(int[] data,int low,int high){

int pivotIndex=(low+high)/2;

swap(data,pivotIndex,high);

int k=partition(data,low-1,high,data[high]);

swap(data,k,high);

if ((k-low)>1) partition(data,low,k-1);

if ((high-k)>1) partition(data,k+1,high);

}

public static int partition(int[] data int low,int high, int pivot ){

do {

while (data[++low]<pivot) ;

while (high!=0   && data[--high]>pivot);

swap(data,low,high);

}

while (low<high) ;

swap(data,low,high);

return low;

}

public static void swap(int[] data int low,int high){

int tmp=data[low];

data[low]=data[high];

data[high]=tmp;

}

public static void main(String[] args){

int[] data = new int[]{89,32,425,32,78,1,53,92};

sort(data);

}

4.试用递归的方法写一下计算菲波那契数列的通项f(n),已知f1=1,f2=1,以后每项都是前两项的和。

..............

public static long fibonacci(long m){

if (m==0 || m==1) return m;

else return fibonacci(m-1)+fibonacci(m-2);

}

5. 写一个Singleton出来。

Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。

我的评论:第一种形式是饿汉式单例类,第二种是懒汉式单例类;可以如此速记,饿汉式太饿了,所以迫不及待在内部new出一个实例,而懒汉式太懒了,所以知道应用时才检查有没有实例存在,如不存在才new一个实例出来。

一般Singleton模式通常有几种种形式:

第一种形式: 定义一个类,它的构造函数为private的,它有一个static的private的该类变量,在类初始化时实例话,通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

Public class Singleton {

private Singleton(){}

//在自己内部定义自己一个实例,是不是很奇怪?

//注意这是private 只供内部调用

private static Singleton instance = new Singleton();

//这里提供了一个供外部访问本class的静态方法,可以直接访问

public static Singleton getInstance() {

return instance;

}

}

第二种形式:

public class Singleton {

private static Singleton instance = null;

public static synchronized Singleton getInstance() {

//这个方法比上面有所改进,不用每次都进行生成对象,只是第一次

//使用时生成实例,提高了效率!

if (instance==null)

instance=new Singleton();

return instance;

}

}

其他形式:

定义一个类,它的构造函数为private的,所有方法为static的。

一般认为第一种形式要更加安全些

6、创建一个静态方法,给它传入一个对象,请循环的打印出该对象所在类的类名和所实现的方法名(华为笔试最后一道编程)

import java.lang.reflect.*;

public class Test{

public static void test(Object obj){

Class clazz=obj.getClass();

//System.out.println("类名:"+clazz.getName());

Method[] ms=clazz.getDeclaredMethods();

long len=Array.getLength(ms);

for(int i=0;i<len;i++){

System.out.println("类名:"+clazz.getName()+"方法名:"+ms[i].getName());

}

}

class A{

public void b(){}

public void c(){}

public void d(){}

public void e(){}

}

public static void main(String[] args){

Test t=new Test();

Test.A a=t.new A();

test(a);

}

}

7、假设字符串类似这样的aba和aab就相等,现在随便给你二组字符串,请编程比较他们看是否相等

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String s = null;

try {

s = br.readLine();

} catch (IOException e) {

e.printStackTrace();

}

StringTokenizer st = new StringTokenizer(s);

String s1 = st.nextToken();

String s2 = st.nextToken();

byte[] sa1 = s1.getBytes();

byte[] sb2 = s2.getBytes();

Arrays.sort(sa1);

Arrays.sort(sb2);

String ss1 = new String(sa1);

String ss2 = new String(sb2);

if(ss1.equals(ss2))

System.out.println("equal");

else

System.out.println("not equal");

8、给你一组字符串如:iu7i8hy4jnb2,让你编程输出里面的数字:7842

用正规表达式:"iu7i8hy4jnb2".replaceAll("[^\\d]","");

9、给你一组字符串让你把它倒叙输出

public static String flashBack(String origin) {

String result = "";

for (int i = origin.length(); i > 0; i--) {

String tmp = origin.substring(i - 1, i);

result += tmp;

}

return result;

}

10、给你一组字符如{1,3,4,7,2,1,1,5,2},让你输出里面出现次数最多且数值最大的一个,出现几次

public void fun4() {

int[] a = { 4, 1, 2, 4, 5, 1, 1, 1, 5, 1, 3, 4, 5 };

Arrays.sort(a);

for (int i = 0; i < a.length; i++) {

System.out.print(a[i] + " ");

}

System.out.println();

int maxNumber = a[a.length - 1], maxCount = 1;

int curNumber = a[a.length - 1], curCount = 1;

for (int i = a.length - 1; i > 0; i--) {

curNumber = a[i];

if (a[i] == a[i - 1]) {

curCount++;

} else {

System.out.println("i=" + i + ",curCount=" + curCount+ ",maxCount=" + maxCount + ",maxNumber=" + maxNumber);

if (curCount > maxCount) {

maxCount = curCount;

maxNumber = curNumber;

}

curCount = 1;

}

}

if (curCount > maxCount) {

maxCount = curCount;

//maxNumber = curNumber;

}

System.out.println("curCount=" + curCount + ",maxCount=" + maxCount + ",maxNumber=" + maxNumber);

}

11、求两个数的公约数,M,N

int divisor =1;

for (int i = 2; i <= b; i++) {

if(a%i==0 && b%i==0){

divisor = i;

}

}

System.out.println(a+"和"+b+"的最大公约数是:"+divisor);

}

12、实现数组复制

我的理解:这是深复制,数组a,b不再有关联

public void fun8(){

int[] a = {1,2,3,4,56,7,8};

int[] b = (int[])a.clone();

Conica.print(a);

Conica.print(b);

b[0]=100;

Conica.print(a);

Conica.print(b);

}

13、冒泡排序的实现

public void fun9(){

int[] a = {1,5,2,6,8,74,1,25,69,8};

Conica.print(a);

for(int i=0; i<a.length-1; i++){

for(int j=0; j<a.length-i-1;j++){

if(a[j]>a[j+1]){

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

Conica.print(a);

}

14、编程显示某一文件目录下的文件名

public void fun10(){

File file = new File("G:\\03月份");

if(file.exists()){

if(file.isDirectory()){

String[] files = file.list();

Conica.println(files);

}

}

}

15、从键盘输入4个十进制数字字符,将其转换为4位时间之数并显示出来

16、编程实现统计文本文件中某个单词的出现频率,并输出统计结果

用HashMap来解决

假设单词不存在跨行的,每个单词用,. ;分割

public static void countNum() throws IOException {

BufferedReader br = null;

try {

br = new BufferedReader(new FileReader("c://file.txt"));

Map map = new HashMap();

for (String s = br.readLine(); s != null; s = br.readLine()) {

StringTokenizer st = new StringTokenizer(s, ",.   ;");

while (st.hasMoreTokens()) {

String temp = st.nextToken();

if (map.containsKey(temp)) {

map.put(temp, new Integer((Integer)map.get(temp) + 1));

} else {

map.put(temp, new Integer(1));

}

}

}

for (Iterator it = map.entrySet().iterator(); it.hasNext();) {

Map.Entry entry = (Map.Entry) it.next();

System.out.println(entry.getKey() + "-->" + entry.getValue()

+ "times");

}

} finally {

br.close();

}

}

17、编程模仿DOS下的dir命令,列出某个目录下的内容

18、编程说明String和StringBuffer字符串的区别

19、编程计算N!的程序,一个使用递归方法,一个不用递归方法

递归 :

long fuction(int n){

if (n==0) return 1;

else

return n* fuction(n-1);

}

不递 :

long s=1;

for(int i=2;i<=n;i++)

{

s*=i;

}

20、编程实现ASCII码和Unicode码之间的转换

21.用1、2、2、3、4、5这六个数字,用java写一个main函数,打印出所有不同的排列,如:512234、412345等,要求: "4 "不能在第三位, "3 "与 "5 "不能相连.

import   java.util.*; 
public   class   test   { 
       static   int   count=0; 
        public   static   void   main(String[]   arg)   { 
                Scanner   r=new   Scanner(System.in); 
                String   s=r.nextLine(); 
                Pailie(s, " "); 
                System.out.println( "Total: "+count); 
           } 
            static   void   Pailie(String   s,String   p)   { 
                if(s.length() <1)   { 
                System.out.println(p);//字符串长度小于1,换行 
                count++; 
                } 
                else   { 
                int   index[]=new   int[s.length()]; 
                for(int   i=0;   i <s.length();   i++)

//该循环将所有字符的第一次出现的位置记      录在数组index中 
                index[i]=s.indexOf(s.charAt(i)); 
                for(int   i=0;   i <s.length();   i++)   { 
                if(i==index[i])

//只有当循环数与第一次记录数相等时才递归,保证相同字符中  的第一个调用 
                Pailie(s.substring(1),p+s.substring(0,1));//递归,打印其它字符 
                s=s.substring(1)+s.substring(0,1);//循环移位 
                        } 
                } 
        } 
}

22。一个字符串中可能包含a~z中的多个字符,如有重复,如String data="aavzcadfdsfsdhshgWasdfasdf",求出现次数最多的那个字母及次数,如有多个重复的则都求出。〔金山公司面试题〕

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.TreeSet;

public class FindRepeatChar {

public static void doString(String strInput) {

char[] chars = strInput.toCharArray();

ArrayList lists = new ArrayList();

TreeSet set = new TreeSet();

for (int i = 0; i < chars.length; i++) {

lists.add(String.valueOf(chars[i]));

set.add(String.valueOf(chars[i]));

}

System.out.println(set);

Collections.sort(lists);

System.out.println(lists);

StringBuffer sb = new StringBuffer();

for (int i = 0; i < lists.size(); i++) {

sb.append(lists.get(i));

}

strInput = sb.toString();

System.out.println(strInput);

int max = 0;

String maxString = "";

ArrayList maxList = new ArrayList();

for (Iterator its = set.iterator(); its.hasNext();) {

String os = (String) its.next();

int begin = strInput.indexOf(os);

int end = strInput.lastIndexOf(os);

int value = end - begin + 1;

if (value > max && value > 1) {

max = value;

maxString = os;

maxList.add(os);

} else if (value == max) {

maxList.add(os);

}

}

int index = 0;

for (int i = 0; i < maxList.size(); i++) {

if (maxList.get(i).equals(maxString)) {

index = i;

break;

}

}

System.out.println("出现最多的字符为:");

for (int i = 0; i < maxList.size(); i++) {

System.out.println(maxList.get(i) + "");

}

System.out.println();

System.out.println("出现最多的次数为:" + max);

}

public static void main(String[] args) {

String strInput = new String("aavzcadfdsfsdhshgWasdfasdf");

doString(strInput);

}

}

第四章:J2EE高级软件工程师面试题

                         -----面试技巧篇

面试技巧
一、 面试的准备
面试准备主要是克服怯场的心理状态。
面试中应注意以下几点:
1、 要坚持平常的心态、平静的心情
2、 不要把面试的成败看得太重
3、 要增强自信心
4、 不要把考官看得过于神秘
5、 要保持愉快的心理状态(愉快的心情能更好地发挥主动性)
二、影响面试的因素
(一) 积极因素 
1、 信心
2、 诚实
3、 让主试者相信你对该部门十分有利,是一个有用的必要人物
4、 礼貌(避免让人反感)
(二) 消极因素
1、 迟到
2、 好高婺远、眼高手低
3、 满不在乎、粗鲁无理的态度 
三、面试技巧
(一) 面试的着装技巧(着装技巧法)
1、 灵活多样、随机应变
2、 突出自我、展示特色
3、 不求时髦 注意服装必须反映自己的气质、个性性格、教育及内涵等
4、 协调 服装打扮及仪态要符合所在单位的习惯、节奏和风格
5、 忌讳 尽量避免暴露及挑逗性的服饰
6、 整洁最为重要
(二) 面试的回答技巧
1、 礼貌用语
2、 言语要形象生动、富有情趣
3、 沉着冷静(琢磨对方的问题动机、防止冷不防提出的问题)
4、 表达简洁清楚
(三) 面试的聆听技巧
1、 耐心----就是自己心情平静安定,以认真的态度听对方讲话。即使是很普通的问题、或者自己已经知道的问题也要认真听。 
2、 专心----就是在面试当中,一定要专心,一是讲礼貌的基本要求,二是满足人尊重需要的要求。还要注意注视对方,善于用表情如微笑、眼神等来表达自己形形色色的心理内涵。在必要的时候还要注意作好笔记。
3、 细心----因为面试是一个综合考察一个人的能力、知识、素质的过程,所以要求应试者要有敏锐的观察能力,就是细心。
关于提问:
外资企业面试时考官最爱提的十个问题 
1.请介绍一下你自己。 

  这是外企常问的问题。一般人回答这个问题过于平常,只说姓名、年龄、爱好、工作经验,这些在简历上都有,其实,外企最希望知道的是求职者能否胜任工作,包括:最强的技能、最深入研究的知识领域、个性中最积极的部分、做过的最成功的事,主要的成就等,这些都可以和学习无关,也可以和学习有关,但要突出积极的个性和做事的能力,说得合情 

  合理外企才会相信。外企很重视一个人的礼貌,求职者要尊重考官,在回答每个问题之后都说一句“谢谢 ”。外企喜欢有礼貌的求职者。   2.在学校你最不喜欢的课程是什么?为什么?  这个问题外企不希望求职者直接回答“数学”、“体育”之类的具体课程,如果直接回答还说明了理由,不仅代表求职者对这个学科不感兴趣,可能还代表将来也会对要完成的某些工作没有兴趣。这个问题外企招聘者最想从求职者口里听到:我可能对个别科目不是特别感兴趣,但是正因为这样,我会花更多的时间去学习这门课程,通过学习对原本不感兴趣的科目也开始有了兴趣,对于本来就有兴趣的科目我自然学习得更认真,所以各门课的成绩较为平衡。通过这样的问题,外企可以找到对任何事情都很感兴趣的求职者。 

  3.说说你最大的优缺点?  这个问题外企问的概率很大,通常不希望听到直接回答的缺点是什么等,如果求职者说自己小心眼、爱忌妒人、非常懒、脾气大、工作效率低,外企肯定不会录用你。外企喜欢求职者从自己的优点说起,中间加一些小缺点,最后再把问题转回到优点上,突出优点的部分。外企喜欢聪明的求职者。

  4. 你认为你在学校属于好学生吗?  外企的招聘者很精明,问这个问题可以试探出很多问题:如果求职者学习成绩好,就会说:“是的,我的成绩很好,所有的成绩都很优异。当然,判断一个学生是不是好学生有很多标准,在学校期间我认为成绩是重要的,其他方面包括思想道德、实践经验、团队精神、沟通能力也都是很重要的,我在这些方面也做得很好,应该说我是一个全面发展的学生。”如果求职者成绩不尽理想,便会说:“我认为是不是一个好学生的标准是多元化的,我的学习成绩还可以,在其他方面我的表现也很突出,比如我去很多地方实习过,我很喜欢在快节奏和压力下工作,我在学生会组织过××活动,锻炼了我的团队合作精神和组织能力。” 有经验的招聘者一听就会明白,外企喜欢诚实的求职者。

  5.说说你的家庭。  外企面试时询问家庭问题不是非要知道求职者家庭的情况,探究隐私,外企不喜欢探究个人隐私,而是要了解家庭背景对求职者的塑造和影响。外企希望听到的重点也在于家庭对求职者的积极影响。外企最喜欢听到的是:我很爱我的家庭!我的家庭一向很和睦,虽然我的父亲和母亲都是普通人,但是从小,我就看到我父亲起早贪黑,每天工作特别勤劳,他的行动无形中培养了我认真负责的态度和勤劳的精神。我母亲为人善良,对人热情,特别乐于助人,所以在单位人缘很好,她的一言一行也一直在教导我做人的道理。外企相信,和睦的家庭关系对一个人的成长有潜移默化的影响。

  6.说说你对行业、技术发展趋势的看法?  外企对这个问题很感兴趣,只有有备而来的求职者能够过关。求职者可以直接在网上查找对你所申请的行业部门的信息,只有深入了解才能产生独特的见解。外企认为最聪明的求职者是对所面试的公司预先了解很多,包括公司各个部门,发展情况,在面试回答问题的时候可以提到所了解的情况,外企欢迎进入企业的人是“ 知己”,而不是“盲人”。

  7.就你申请的这个职位,你认为你还欠缺什么?  外企喜欢问求职者弱点,但精明的求职者一般不直接回答。他们希望看到这样的求职者:继续重复自己的优势,然后说:“对于这个职位和我的能力来说,我相信自己是可以胜任的,只是缺乏经验,这个问题我想我可以进入公司以后以最短的时间来解决,我的学习能力很强,我相信可以很快融入公司的企业文化,进入工作状态。”外企喜欢能够巧妙地躲过难题的求职者。 

  8.你期望的工资是多少?  外企的工资水平是很灵活的,何种能力拿何种工资。外企喜欢直率的人,但这个问题却不能正面回答,外企希望听到:“以我的能力和我的优势,我完全可以胜任这个职位,我相信我可以做得很好。但是贵公司对这个职位的描述不是很具体,我想还可以延后再讨论”。外企欢迎求职者给其定薪的自由度,而不是咬准一个价码。

  9.你能给公司带来什么?  外企很想知道未来的员工能为企业做什么,求职者应再次重复自己的优势,然后说:“就我的能力,我可以做一个优秀的员工在组织中发挥能力,给组织带来高效率和更多的收益”。外企喜欢求职者就申请的职位表明自己的能力,比如申请营销之类的职位,可以说:“我可以开发大量的新客户,同时,对老客户做更全面周到的服务,开发老客户的新需求和消费。”等等。 

  10.你还有什么问题吗? 

  外企的这个问题看上去可有可无,其实很关键,外企不喜欢说“没有问题”的人,因为其很注重员工的个性和创新能力。外企不喜欢求职者问个人福利之类的问题,如果有人这样问:贵公司对新入公司的员工有没有什么培训项目,我可以参加吗?或者说贵公司的晋升机制是什么样的?外企将很欢迎,因为体现出你对学习的热情和对公司的忠诚度以及你的上进心。

2009面试的十大禁忌

禁忌一:恶意缺席
    
    接到面试通知,如果不能或不想出席,都应该在前一至三天用电话婉转地通知对方。许多求职者可能会认为,反正我已决定不去这家公司上班,何必和对方有所接触?这绝对是错误的观念,留下恶意缺席的印象,对你日后要在这个行业中发展,一定有所影响。
    
禁忌二:不守时
    
    面试时的守时十分重要,迟到是绝对不可原谅的行为,代表你对这家公司根本不重视。太早到也不好,面试官可能有别的事情,还要应付你的突然出现。
    
禁忌三:穿着邋遢
    
    不管你应征何种类型的工作,穿着是给别人留下第一印象的机会。即使是所谓创意型的人员,邋遢、不修边幅的着装,还是不易令人亲近。是不是西装革履其实并不重要,要把握干净、整洁的原则,才能留下好印象。
    
禁忌四:没有准备
    
    就算你是一个毫无经验的社会新鲜人,对于应征职务的工作性质、内容,也应该有一些基本的认识与了解。企业当然可以容忍新鲜人缺乏经验,但是没有准备、一问三不知的人,似乎也意味着将来在工作上缺乏责任感。更现实的说法,企业可能要花两、三倍的时间才能让你达到工作的要求。
    
禁忌五:欺骗
    
    没有一家企业会录用不诚实的新人,在面试的过程中,诚实是最好的应对之策。尤其是履历表、自传中所写的个人背景资料,不要夸大自己的能力,或是谈话内容和履历表所写不符。即使面试时未被发觉,日后也会被检验。
    
禁忌六:言行轻浮
    
    面试代表的是一种对个人性格的主观判断,轻浮的言行、夸张的肢体动作,会令人有不信任的感觉。面试官最讨厌的是一副无所谓、可有可无的态度,如果你对这家公司没有兴趣,又何必来应征呢?
    
禁忌七:没有自信,或流露骄傲
    
    自信和骄傲有时就在一线之间,尺寸的拿捏要小心掌握。没有自信的人会让人有学习力差、推诿搪塞的联想,肯定不受企业欢迎;骄傲的人则令人生厌,没有团队合作的概念、不合群,企业可不想用一个单打独斗的独行侠。
    
禁忌八:天马行空
    
    说话的逻辑概念,代表的是一个人的组织能力。天马行空可能是一种创意,却也代表着“只会说不会做”的言行失衡。企业应征社会新鲜人,多半是希望做好基层的执行工作,有创意当然是额外的红利,只动嘴不动手可不是新人该做的事。
    
禁忌九:喜好批评却无创见
    
    没有一个主管喜欢爱批评却无创见的员工,面试官也一样。即使批评的是和工作无关的事,像是政治、经济、社会的现况,对于求职者来说,并没有任何加分的效果,可能还会因为你的言语不当,引起面试官的不快。
    
禁忌十:不知行情乱开价
    
    谈到薪水多半代表你有很大的机会被录取,可是你却来个狮子大开口,企业怎么敢用一个漫天要价的人?如果你不想吃亏,面试前应多打听相关行情,否则就采取“依公司规定”的保守策略。不知行情胡乱开价,绝对让你的面试倒扣200分

 

3、  好的自我介绍

怎样做好面试准备,汇总多为招聘专家的意见,我们给出在面试在自我介绍环节中,应该掌握的几点基本技巧: 
  
开门见山,简明扼要,不要超过三分钟(最好准备1、2、3分钟分别的的介绍内容,以应对不同的要求,即使在没有时间限制的情况下,个人建议在2分钟以内比较好)

实事求是,适当夸张(我们可以稍微、适当的吹嘘一下自己,但是切忌,不要吹过了头,因为诚实很重要)

突出长处,但也不隐瞒短处。(面试官了解了你长处的同时,当然也想知道你的短处,因为优点和缺点的平衡也是很大的一个考核标准,你也不会招聘一个缺点大于等于优点的员工吧?)

所突出的长处要与申请的职位有关。(如果你是狙击手,让你跟一个原始人拼长矛,你觉得你的长处能派上用场吗?)

善于用具体事例来证明自己,说明问题,(一件事例,往往比你说一堆道理更能证明自己)

以上技巧需要广大求职者,特别是应届生面试者在自我介绍环节中一定要特别注意,因为刚刚毕业缺乏面试经验,一不小心讲自我介绍弄成详细的个人情况,世界观,哲学观等等的介绍。

爱编程-编程爱好者经验分享平台

文章评论

  

版权所有 爱编程 © Copyright 2012. w2bc.com. All Rights Reserved.
闽ICP备12017094号-3