java学习期间总结
-------------------java基础---------------
-------------IO流--------------
IO流：字符流(字节 字符) 字符流每次读取16个字节单位的数据
字节流(只流字节) 字节流每次读取8个字节单位的数据
注：一个中文两个或多个字节
常见的IO类：
ByteArrayInputStream ----- 内存流---把信息存入内存中的一个缓冲区中
PipedInputStream -----管道流----实现了pipe的概念，主要在线程中使用
SequenceInputStream -----顺序连结流
ObjectInputStream -----对象流
BufferedInputStream -----缓存流
DataInputStream -----特殊流
PushbackInputStream -----回压流
FileOutputStream -----文件输入流-----把信息存入文件中
面试点：***************
-----------------------异常-----------------------
异常：java异常是java提供的用于处理程序程序中错误的一些异常事件。运行期出现的错误。
throwable：Errow(错误 不可恢复)
Exception(异常 可恢复)
Exception：系统异常(系统已写好)
自定义异常
也分为：检查性异常(Exception直接子类 必须捕获) 不检查性异常(runtime直接子类)
1.图
2.五个关键字：try catch finally throw throws
3.catch原则 先小的 后大的
4.异常与重写的关系
自定义异常的实现：自定义类实现RuntimeException接口 在本类的构造方法调父类的构造方法(super()) 并传入自定义内容 在另一类中直接抛出该类对象
常见的异常：
ArrayIndexOutOfBoundsException
ArrayStoreException
ClassNotFoundException
ClassCastException
IllegalAccessException
IllegalArgumentException
NullPointerException
----------------------------线程---------------------------
线程：线程从本质上说是一个正在执行的程序 它拥有自己独立的数据空间 占有一定的系统资源
线程与进程的关系：线程是进程的细分 它是进程内部的一个顺序控制流 有一个入口 一个出口 还有一个顺序执行序列
与进程不同的是 线程不能单独运行 必须依赖某个进程运行 统一进程中的所有线程共享进程所有的资源。
线程：守护线程
用户线程
线程的五种状态：新建 就绪 运行 阻塞(挂起) 终止(死亡)
创建线程的两种方式：继承Thread
实现runnable接口
比如：A a = new A(); Thread temp = new Thread(a); temp.start();
造成死锁的原因和解决方法：
原因：每条线程都调用了suspend方法 被挂起了 都等待着另一条线程调用resume 方法唤醒自己。
解决方法：
线程安全转化为线程不安全?
1.加synchronizd
2.调用sleep()方法。
3.调用wait()方法 再调用notify()方法；
---------------java.util-----------------
各个容器间的区别和联系
------------------补充----------------------
java 内置注解：
@Override
@Deprected
@SuppressWarning
java中实现多态的机制？
方法重写和方法重载
重写：是父类与子类之间多态性的一种表现
重载：是一个类中多态性德表现
对象的操作方法有哪些？
直接序列化 传参 返回值 数组 反射
对象序列化：
把一个对象任意时候的状态保存到web机制(外部文件)
反序列化：
web机制把对象的状态还原到对象中
-----缓存的作用
----------------反射---------------------
反射：Java提供了一套机制来动态执行方法和构造方法，以及数组操作等，这套机制就叫——反射
反射机制主要提供以下功能：
1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）
4.在运行时调用任意一个对象的方法（*****注意：前提都是在运行时，而不是在编译时）
例子：
创建实例：
1.Class c = Class.forname("xxxx"); // 得到一个类的class对象
Constractor con = c.getConstractor(String.Class); // 传入参数的class 对象
Stu stu = con.newInstance("xxxxxx"); // 传入参数 并 得到对象
2.Class c = Class.forName("xxxx");
Stu stu = (Stu)c.newInstance(); /// 得到对象
方法区别：
class 对象-----
getDeclaredConstractors(); // 本类的所有构造方法(包括private 修饰)
getDeclaredMethods(); // 得到本类的方法
getMethods(); /// 得到所有的方法(包括父类的)
XML： Extensible Markup Language
XML: 自定义标记语言
HTML: 固定标记语言
定义XML的方式：DTD
Schema
-----------------------------------XML的解析----------------------------------
-------dom4j 解析xml文件例子：-----------
Document document = null;
try
{
document = new SAXReader().read(filePath);// 得到document 对象
} catch (DocumentException e)
{
e.printStackTrace();
throw new GeneralException("Dom4j解析配置文件jdbc.xml出现异常！");
}
Element root = document.getRootElement(); //得到根节点对象
Iterator<Element> iter = root.elementIterator("db"); // 得到根节点下的所有元素
while(iter.hasNext()){
Element element = iter.next();
String type = element.elementText("type");// 拿到具体的值
}
---------SAX 解析xml文件例子---------
优点：
因此不需要将数据存储在内存中。
SAX 解析器采用了基于事件的模型 可以激活一个回调方法。
public class Ceshi extends DefaultHandler{ // 需要继承DefaultHandler 并实现里面的方法
public static void main(String[] args)
{
String filename = "WebContent/WEB-INF/ceshi.xml";
SAXParserFactory spf = SAXParserFactory.newInstance();
try
{
SAXParser saxParser = spf.newSAXParser();
saxParser.parse(new File(filename), new Ceshi());
}catch (){
}
在startElement 方法循环迭代出来
---------------------------ajax-------------------------------
创建一个ie 对象 判断为ie 或非ie
--------------------基础面试点---------------------
java.lang包
String，StringBuffer，StringBuild各自的含义的区别
截取字符串的编程题
反射(java reflection的定义和用法。
请问java下Class.forName的作用是什么，为什么要使用它
NEW了一个String对象问你这个共有几个对象
java.io包
java中有那几种流（最基础的）？
io和nio(new io)的区别以及nio的用法。
写一段程序，如何读取一个文件夹所有的文件和子文件夹的所有文件
java.io.Reader与java.io.InputStream的区别
什么是序列化？序列化的作用?
java.io.StringWriter,什么时候调用 他的flush方法,以及StringWriter的作用
java.net包
tcp和udp的区别？
socket怎么得到当前ip
通过Socket来编写一个聊天程序。
java.sql包
给你ip,数据库名，表名，密码要你将通过jdbc连接，并查出前100条数据的过程代码
请写出jdbc调用存储过程的代码
插入10万条数据用jdbc语句怎么写。
preparedstatement与statement的区别？
jdbc里你是怎么样进行批处理的。
java.util包
ArrayList,LinkedList和HashMap的各种比较,比如ArrayList 同 Vector的比较,HashMap同treeMap的比较, ArrayList同LinkedList的比较,数组和ArrayList的区别，List与Set区别，Set与Map区别；
简述HashMap原理，并画出它的结构图；
Collection和Collections的区别
线程
什么叫线程？谈谈你对多线程的理解
多线程有几种实现方法，都是什么?
sleep和wait区别？
java线程里的wait，sleep，synchronzied，notify分别有什么作用?
启动线程有那几种方式？
唤醒一个线程与唤醒所有线程的方法分别是？
有两个线程,一个线程每分钟把系统时间写入一个文件,另一个线程读出文件里的数据.
同步与异步的区别? 在什么情况下分别使用？同步的方法有哪些?
进程与线程的概念理解
线程的状态控制
设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
异常
EROOR与Exception的区别
------------------------------Ext----------------------------
Ext：ExtJs的简称 是一个强大的Js类库
ExtJs框架支持Ajax实现 通常 Ajax 应用程序的一个公用特征是应用程序可以异步的响应用户输入 它会刷新局部用户界面而不需要重新显示整个Web界面
ExtJs中基本组件体系：
基本组件
工具栏组件
表单及字段组件
基本组件：
box
button
component
container
panel
1.ext它提供了一套非常绚丽的UI，与后台无关的框架。
2.ext是一套开源的框架。
3.容器组件用来装组件的。
4.ext.form.FormPanel用来装表单组件的。
5.容器是用来装东西的(记好了)。
6.所有的表单组件都继承field组件。
7.组件(都是BoxComponent下面的组件):基本组件，工具栏组件（tbar下面的组件），表单组件(表单下面的组件)。
8.所有的组件销毁都是引用BoxComponent来的。
9.ext中一个组件代表一个类，要用组件直接new一个就可以，默认的情况下所有的组件都初始化了。
10.当对象指向rendering以后，每一个对象都对应一个DOM。
1.Ext的核心组件(component):自动支持了标准的隐藏，显示，启用，禁用等，Ext中每一个组件都对应着一个xtype属性，在Ext中xytpe直接可以创建组件，所有的组件都可以通过renderTo来进行渲染html页面。
2.组件的生命周期是:创建，初始化，销毁。
3.Ext.container有两个重要的属性:1.layout2.items。
4.页面布局都交给Viewport来管理。
5.Ext实用工具:1.onReady()
6.js中没有静态的，静态的就是一个函数。
7.get方法是获取HTML元素或者ext元素的一个函数，返回来的数据类型是Ext.element，必须通过id或者dom对象。
8.getCmp用来获得一个Ext组件。
9.getBody返回当前body的element。
10.borderLayout布局:把界面分成了5部分，东南西北中，中是一定要的(如果没有中，就报布局出错)。
-------------------------------------JQuery-----------------------
JQuery是一个类库 为web的javascript开发提供辅助功能
JQuery使用户能方便的处理HTMLdocument Event 实现动态效果并且方便的为网站提供ajax 交互。
优势：
文档说明很全 而且各种应用也说的很详细
很多成熟的插件
JQuery----->$
jquery的得值方式：
$("#id")[0].value() -----转化为DOM 元素取 debug调试发现
$("#id").val() -----直接调方法取
$(dom) DOM---->Jquery
------------------------------过滤器的使用-----------------
1.实现Filter接口 重写init() doFilter() destroy()方法
2.具体的操作
public class CharacterEncodingFilter implements Filter {
private FilterConfig config = null; //filet配置
private String encoding = "UTF-8"; // 默认字符编码
public void init(FilterConfig config) throws ServletException {
this.config = config;
this.encoding = config.getInitParameter("encoding");//web.xml配置参数
}
/**
* 字符处理方法
*/
public void doFilter(ServletRequest srequest, ServletResponse sresponse,
FilterChain chain) throws IOException, ServletException {
if (null != encoding) {
HttpServletRequest request = (HttpServletRequest)srequest;
HttpServletResponse response = (HttpServletResponse)sresponse;
// 对请求进行编码设置
request.setCharacterEncoding(encoding); //把请求用指定的方法编码
response.setContentType("text/html");
response.setCharacterEncoding(encoding); //把返回响应指定 编码方式
System.out.println("------------过滤编码-------------" + encoding);
}
// 把处理权限交给下一个过滤器
chain.doFilter(srequest, sresponse);
}
public void destroy() {
}
}
3.web.xml 配置
<filter>
<filter-name>filter</filter-name>
<filter-class>servlet.filter.filter</filter-class>
<init-param>
<param-name>encoding</param-name> ///可传参数
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>filter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
--------------------------DButil-----------------------------
解决的问题：
a、大量的重复代码
b、jdbc的简单封装
c、使用策略模式可以生成不同的返回类型
涉及技术：
a、反射
b、泛型
c、元数据
d、可变参数
缺点：没有进行事务处理
流程：
调用query 方法(具体的) ---->适配器模式兼容查询功能 预处理------->选择类型-------->创建bean 利用反射机制生成一个对象
用法：
1.定义一类：继承BasicDataSource 并定义一方法 用this 定义父类连结数据库的属性
public class LoginDataSource extends BasicDataSource{
public LoginDataSource() {
this.setDriverClassName("com.mysql.jdbc.Driver");
this.setUsername("root");
this.setPassword("123");
this.setUrl("jdbc:mysql://192.168.2.72/english?useUnicode=true&charactorEncodering=UTF-8");
}
}
2.得到QueryRunner 构造QueryRunner 有两种方法：无参 ，DataSource类型的参数 采用后一种
QueryRunner queryRunner= new QueryRunner(new LoginDataSource());
3.执行具体的SQL操作
queryRunner.query();
queryRunner.update();
.......
Connection connection = queryRunner.getDataSource().getConnection(); // 得到连结对象
---------------------UML--------------------------------------
UML：统一建模语言
UML为面向对象开发系统的产品进行说明、可视化、和编制文档的一种标准语言。
UML最适于数据建模，业务建模，对象建模，组件建模。
UML的内容：
(1) UML语义
描述基于UML的精确元模型定义。元模型为UML的所有元素在语法和语义上提供了简单、一致、通用的定义性说明，
使开发者能在语义上取得一致，消除了因人而异的最佳表达方法所造成的影响。此外UML还支持对元模型的扩展定义。
(2) UML表示法 标准建模语言UML的重要内容可以由下列五类图（共9种图形）来定义
第一类是用例图
第二类是静态图 (Static diagram)，
第三类是行为图（Behavior diagram），
第四类是交互图（Interactive diagram），
第五类是实现图 ( Implementation diagram )。
用例图的关系：包含关系：用例可以简单地包含其他用例具有的行为，并把它所包含的用例行为做为自身行为的一部分，这被称作包含关系
扩展关系：意外情况
类图的三种关系：关联：一个类的实例必须要用到另一类实例 才能完成工作叫关联
聚合：带菱形的连线
泛化：一个指向其他类作为超类的继承连线
--------------------------ubuntu 简单操作-------------------
touch ----->生成新的文件
sudo ----->设置密码
rm file --->删除文件
mkdir --->新建目录
加 -r --->删除目录
ls： --->清单
面试点：
rm命令可删除文件或目录，其主要差别就是是否使用递归开关 -r或-R 。
查看当前监听80端口的程序
lsof -i :80
查看当前有哪些进程
ps -A
查看当前的内存使用情况
free -l
查看CPU信息
cat /proc/cpuinfo
---------------------------CC 持续集成-----------------------
持续集成是一种软件开发实践 简称ci 可以让程序员持续不断的集成svn上的代码 是为了解决程序员手动检出svn上最新的代码的问题而出现
优点：
更容易发现bug 因为单独提供了一个单元测试的页面 自动的测试 并将测试结果反馈在页面上 自动 不间断的检测svn上的代码 并更新
安全性比较高
自动化程度比较高
缺点：配置文件过于复杂 特别是config文件
公司怎么用的：
首先下载一个cc工具 并配置环境变量 然后在dos命令中 检 出svn服务器 上的项目 并且在 config.xml文件进行项目的相关配置 比如项目名 和自动检测的间隔时间和延迟时间 如果有改动就及时更新 首先会找到build.xml文件 build文件首先清空以前的一些垃圾信息比如class文件和目录 然后执行预编译 将项目打包成jar 包 或者war 包 发布tomcat 中 就可以运行了
也可以对项目进行单元测试 和数据库集成 比如数据库集成 首先是对数据库进行清空和删除一些表信息 然后再初始化数据库一些文件信息 就可以持续不断的进行数据库集成了
经验就是：编译后的class文件要放在build 目录的下的class文件夹 并且junit的输入和ant 的输入路径相同 否则找不到测试类
首先是以config.xml文件为入口 并且找到 该项目的build 文件 并首先会清空里面原有的信息比如class文件 然后执行预编译 包括jar包和java文件 然后进行单元测试 和 对数据库进行一些初始化
同类框架比较：
更加自动化···
最佳实践：
经常提交代码
不要提交无法构建的代码
避免检出无法构建的代码
立即修复无法集成的构建
编写自动化测试
必须通过所有的测试和审查
执行私有构建
自动化构建
自动化数据库集成
使用本地数据库沙盒
执行单命令构建
创建一致的目录结构
及时的提交可构造的代码 保持svn上代码的正确性
自动化单元测试
自动化功能测试
自动化系统测试
自动化组件测试
svn检出：
先将ant有关的jar包导入 到cc工具中 因为eclipse 没有自带
然后配置 svn 的地址 用户名 密码等 连结属性
让后配置里面的 svn 节点的配置 就可以自动的检出svn上的代码了
---------------------------------spring事物配置----------------------------------
有五种：
第一种方式：每个Bean都有一个代理
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean>
<!-- 定义事务管理器（声明式的事务） -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 配置DAO -->
<bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="userDao"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<!-- 配置事务管理器 -->
<property name="transactionManager" ref="transactionManager" />
<property name="target" ref="userDaoTarget" />
<property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
lt;/beans>
所有Bean共享一个代理基类：
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean>
<!-- 定义事务管理器（声明式的事务） -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="transactionBase"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
lazy-init="true" abstract="true">
<!-- 配置事务管理器 -->
<property name="transactionManager" ref="transactionManager" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 配置DAO -->
<bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="userDao" parent="transactionBase" >
<property name="target" ref="userDaoTarget" />
</bean>
</beans>
第三种方式：使用拦截器：
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean>
<!-- 定义事务管理器（声明式的事务） -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager" ref="transactionManager" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>*Dao</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>
<!-- 配置DAO -->
<bean id="userDao" class="com.bluesky.spring.dao.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
</beans>
第四种方式：使用tx标签配置的拦截器：
<context:annotation-config />
<context:component-scan base-package="com.bluesky" />
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean>
<!-- 定义事务管理器（声明式的事务） -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="*" propagation="REQUIRED" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="interceptorPointCuts"
expression="execution(* com.bluesky.spring.dao.*.*(..))" />
<aop:advisor advice-ref="txAdvice"
pointcut-ref="interceptorPointCuts" />
</aop:config>
lt;/beans>
第五种方式：全注解：
-------------------------
长沙博赛软件有限公司
湖南省长沙市岳麓区景秀路2号
109路,117路,118路,132路,301路,301路区间,317路,318路,401路,804路
毕业院校：
北京科技师范学院 计算机科学与技术
北京科技师范学院创建于1980年
北京市大兴区黄村镇北程庄东路2号院
北京师范大学北校门的旁边
---------------------------------------经典面试----------------------------------
6、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
对于short s1 = 1; s1 = s1 + 1; 由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。
对于short s1 = 1; s1 += 1;由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。
内部类：
特征：在一个类的内部定义的类 其他类不能直接调用 不能定义静态变量 可以访问外部变量
Static Nested Class 和 Inner Class区别：
static Nested Class能访问外部类的非static成员变量。
关于return finally 执行顺序：
<jsp:userbean>中scope有哪几种类型? // scope ：作用域
page — bean只能在单一JSP页面中被访问，寿命期只存在于当前请求（即其为service方法中的局部变量）。
request — bean能在单一JSP页面及此页面include或forward的其他页面或servlet中被访问（即其为Request的属性）。---整个应用用的是同一个bean。 比如：页面刷新
session — bean能在特定用户会话中的所有JSP页面和servlet中被访问（即其为session的属性）。 ---- 这次会话中用的是同一个。
application — bean能在此web应用程序下的所有JSP页面和servlet中被访问（即其为Servlet context的属性）。----整个应用用的是同一个bean。
Cookie与Session的区别，Session的工作原理
Cookie:客户端保存用户信息
Session：服务端保存用户信息 安全性相对要高一些；
session：保存的是对象，cookie中保存的是字符串
通常session cookie是不能跨窗口使用的，当你新开了一个浏览器窗口进入相同页面时，
系统会赋予你一个新的sessionid，这样我们信息共享的目的就达不到了，此时我们可以先把sessionid保存在persistent cookie中，然后在新窗口中读出来，就可以得到上一个窗口SessionID了，这样通过session cookie和persistent cookie的结合我们就实现了跨窗口的session tracking（会话跟踪）。
43、try {}里有一个 return 语句，那么紧跟在这个 try 后的finally {}里的 code 会不会被执行，什么时候被执行，在 return 前还是后?
会执行，在 return 前执行。
如果再加个catch finally加个return语句 会执行后面那个return语句
简述synchronized和java.util.concurrent.locks.Lock的异同 ？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁
Collection 和 Collections的区别。
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
request.getAttribute() 和 request.getParameter()区别：
方式：
1.getParameter取值是基于Post和Get方式的传递的.(url 挂问号传递的值)
getAttribute取值是以编程的方式存储到WEB会话上下面中的，
例如：request.setAttribute("roleList", roleList);
类型：
2.getParameter的值没有类型或者看成是String类型的;
getAttribute的值是对象，可以是String已及用户自已定义的类型
11. jsp有哪些内置对象?作用分别是什么? 分别有什么方法？
答:JSP共有以下9个内置的对象：
request 用户端请求，此请求会包含来自GET/POST请求的参数
response 网页传回用户端的回应
pageContext 网页的属性是在这里管理
session 与请求有关的会话期
application servlet 正在执行的内容
out 用来传送回应的输出
config servlet的构架部件
page JSP网页本身
exception 针对错误网页，未捕捉的例外
request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
response表示HttpServletResponse对象，并提供了几个用于设置送回 浏览器的响应的方法（如cookies,头信息等）
out对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。
session表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息
applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息
config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
page表示从该页面产生的一个servlet实例
12. jsp有哪些动作?作用分别是什么?
（这个问题似乎不重要，不明白为何有此题）
答:JSP共有以下6种基本动作
jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记
16、页面间对象传递的方法
request，session，application，cookie等
7.分页语句
取出sql表中第31到40的记录（以自动增长ID为主键）
sql server方案1：
select top 10 * from t where id not in (select top 30 id from t order by id ) orde by id
sql server方案2：
select top 10 * from t where id in (select top 40 id from t order by id) order by id desc
mysql方案：select * from t order by id limit 30,10
oracle方案：select * from (select rownum r,* from t where r<=40) where r>30
集合类的排序 提示：可实现comparable 接口：
两种：
1.对象本身实现Comparable接口,那么该类的实例就是可以排序的.
只要实现了Comparable接口,就可以调用Collections的sort方法对集合中的元素排序.
TestList // list 排序
TestMap // map 排序
class TestBean{
private int count;
private String name;
public void toString(){
return count+"\t"+name;
}
}
class TestComparator implements Comparator{
public int compare(TestBean o, TestBean oo) {
if(o.count==oo.count){
return 0;
}else if(o.count>oo.count){
return 1;
}else{
return -1;
}
}
}
TreeSet tree=TreeSet(new TestComparator());
tree.add(new TestBean());
2.指定一个Comparator,也就是实现了Comparator的类的一个实例.
但是Java本身只提供了一个Comparator的实现,就是Collections.reverseOrder().
该方法返回的是一个已经实现了Comparable接口的反序.
--------------------待整理进去的内容-------------------------------------
pageSize=20;
pageNo = 5;
1.分页技术1（直接利用sql语句进行分页，效率最高和最推荐的）
mysql:sql = "select * from articles limit " + (pageNo-1)*pageSize + "," + pageSize;
oracle: sql = "select * from " +
"(select rownum r,* from " +
"(select * from articles order by postime desc)" +
"where rownum<= " + pageNo*pageSize +") tmp " +
"where r>" + (pageNo-1)*pageSize;
注释：第7行保证rownum的顺序是确定的，因为oracle的索引会造成rownum返回不同的值
简洋提示：没有order by时，rownum按顺序输出，一旦有了order by，rownum不按顺序输出了，这说明rownum是排序前的编号。如果对order by从句中的字段建立了索引，那么，rownum也是按顺序输出的，因为这时候生成原始的查询结果集时会参照索引表的顺序来构建。
sqlserver:sql = "select top 10 * from id not id(select top " + (pageNo-1)*pageSize + "id from articles)"
4、你对Spring的理解。
1.Spring实现了工厂模式的工厂类（在这里有必要解释清楚什么是工厂模式），这个类名为BeanFactory（实际上是一个接口），在程序中通常BeanFactory的子类ApplicationContext。Spring相当于一个大的工厂类，在其配置文件中通过<bean>元素配置用于创建实例对象的类名和实例对象的属性。
2. Spring提供了对IOC良好支持，IOC是一种编程思想，是一种架构艺术，利用这种思想可以很好地实现模块之间的解耦。IOC也称为DI（Depency Injection），什么叫依赖注入呢？
譬如，Class Programmer
{
Computer computer = null;
public void code()
{
//Computer computer = new IBMComputer();
//Computer computer = beanfacotry.getComputer();
computer.write();
}
public void setComputer(Computer computer)
{
this.computer = computer;
}
}
另外两种方式都由依赖，第一个直接依赖于目标类，第二个把依赖转移到工厂上，第三个彻底与目标和工厂解耦了。在spring的配置文件中配置片段如下：
<bean id=”computer” class=”cn.itcast.interview.Computer”>
</bean>
<bean id=”programmer” class=”cn.itcast.interview.Programmer”>
<property name=”computer” ref=”computer”></property>
</bean>
3. Spring提供了对AOP技术的良好封装， AOP称为面向切面编程，就是系统中有很多各不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，例如，加入日志，加入权限判断，加入异常处理，这种应用称为AOP。实现AOP功能采用的是代理技术，客户端程序不再调用目标，而调用代理类，代理类与目标类对外具有相同的方法声明，有两种方式可以实现相同的方法声明，一是实现相同的接口，二是作为目标的子类在，JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，如果要为某个类生成子类，则可以用CGLI B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法，系统功能的代理以Advice对象进行提供，显然要创建出代理对象，至少需要目标类和Advice类。spring提供了这种支持，只需要在spring配置文件中配置这两个元素即可实现代理和aop功能，例如，
<bean id=”proxy” type=”org.spring.framework.aop.ProxyBeanFactory”>
<property name=”target” ref=””></property>
<property name=”advisor” ref=””></property>
6、四种会话跟踪技术
会话作用域ServletsJSP 页面描述
page否是代表与一个页面相关的对象和属性。一个页面由一个编译好的 Java servlet 类（可以带有任何的 include 指令，但是没有 include 动作）表示。这既包括 servlet 又包括被编译成 servlet 的 JSP 页面
request是是代表与 Web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件（由于 forward 指令和 include 动作的关系）
session是是代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常会跨越多个客户机请求
application是是代表与整个 Web 应用程序相关的对象和属性。这实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域
-----------------------------ibatis------------------------------
1.ibatis中 # 跟 $的区别？
select * from member where id =#id# ------ 适用于传参问题 可以直接传属性值 也可以传javabean ibatis会自动解析
问题：iBATIS默认会把“#”中间的变量作为字符串来处理
解决问题：
使用$将你的变量括起来，iBATIS不会给这个变量做任何的处理，直接生成你要的SQL
简单的说：
使用#号传值 ibatis默认会把#号中间的变量作为字符串来处理。
使用$号传值 ibatis不会给这个变量做任何处理 直接生成你想要的SQL。
$方式一般用于传入数据库对象．例如传入表名;
一般能用#的就别用$ ; 性能问题吧
2.Ibatis中使用like ‘%#filedName#%’ 时，有什么问题？
在xml映射文件中，如果直接按如上写法，会报异常：java.sql.SQLException: Invalid argument in JDBC call: parameter index out of range: 1。
所以一般会采用如下两种方式：
1) 将#换成$，如like ‘%$ filedName $%’，这样就没有问题了..
2) 采用字符串联接符||，如：like ‘%’||# filedName #||’%’
与hibernate相比较：
难易度：a.更容易掌握
SQL:b.更容易进行SQL优化， hibernate的自动生成的sql 有点难看。
c.可以进行细度的优化
1.比如我要查询一个表中的一个或几个字段 直接一个sql 搞定 而hibernate利用面向对象的方式会将所有的数据查出来 就浪费的内存
效率：不考虑hibernate的缓存的话 ibatis的效率要高一些。
可维护性：个人觉得ibatis要好一些。ibatis 的sql 单独保存到一个文件中 易于维护 而hibernate在java代码中保存sql
hibernate的优点：对数据库类型兼容比较好
自动化程度比较高
还得根据不同需求选择不同数据库。
------------------------------WebService-------------------------------
解决了什么问题：
在以往传统应用程序中 采用独立的进程模式 这些应用程序之间没法进行真正通信，彼此间不能共享数据 而Webservice正好解决了一些问题。
Web services（也称web 服务技术）是一种面向服务的架构技术，是一种进行分布式部署和应用的流行方式，通常用来建立可互操作的分布式应用程序
简单地说，Web services就是一个应用程序，它向外界暴露出能够进行远程调用的接口程序。
一种思想 一种架构
一种 SOA 架构 : 面向服务架构
webservicer 的框架：axis1 axis2 xfire cxf
怎么用的？
我用的是axis2 框架
a.浏览器访问：
1.首先是下载----它是apache公司的一个开源框架。
2.解压axis2.war ，然后部署到tomcat/webapps目录下
3.利用POJO实现零配置的WebService
4.编写POJO --- 就是定义一个类和几个方法
5.SimpleService.class文件放到<Tomcat安装目录>\webapps\axis2\WEB-INF\pojo目录中（如果没有pojo目录，则建立该目录）
6.访问：http://localhost:8080/axis2/services/listServices 也可以直接在url 后面带参数过去
b.使用RPC方式调用web service
1.// RPC客户端服务类
RPCServiceClient serviceClient = new RPCServiceClient();
Options options = serviceClient.getOptions();
2.// 指定调用web service的URL
String url = "http://localhost:9090/axis2/services/SimpleService";
EndpointReference taretRef = new EndpointReference(url);
options.setTo(taretRef);
3.// 指定getGreeting方法的返回值的数据类型的calss对象
Object[] opsArgs = new Object[] { "和尚" };
Class[] returnTypes = new Class[] { String.class };
// 指定要调用的getGreeting方法及其WSDL文件的命名空间
QName qName = new QName("http://ws.apache.org/axis2", "getGreeting");
4.调用
System.out.println(serviceClient.invokeBlocking(qName, opsArgs,returnTypes)[0]);
----------------------------------- SSH 框架整合 ------------------------------------------
web.xml 配置文件
<！利用监听器初始化spring 的配置文件applicationContext.xml文件 实现依赖注入 >
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<！struts 的配置>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<！路径拦截>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>
applicationContext.xml 配置文件 spring
<!-- 配置dataSource 数据库连接 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql:///hibernate"></property>
<property name="username" value="root"></property>
<property name="password" value="123"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="hibernateProperties">
<props><!-- 一些属性 比如sql 可见 自动创建表 -->
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<property name="mappingResources">
<list><!-- 初始化javabean映射文件 -->
<value>com/lxit/ssh/bean/person.hbm.xml</value>
</list>
</property>
</bean>
<!-- 一般的spring注入 -->
<bean id="personDao" class="com.lxit.ssh.dao.PersonDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property><!-- hibernate模板需要注入sessionFactory -->
</bean>
<bean id="personService" class="com.lxit.ssh.service.PersonServiceImpl">
<property name="personDao" ref="personDao"></property>
</bean>
<bean name="personAction" class="com.lxit.ssh.web.PersonAction">
<property name="personService" ref="personService"></property>
</bean>
person.hbm.xml----javabean映射配置文件
<hibernate-mapping package="com.lxit.ssh.bean" >
<class name="Person" >
<id name="id">
<generator class="uuid.hex"></generator>
</id>
<property name="name" ></property>
<property name="age" ></property>
</class>
</hibernate-mapping>
---------------------------spring ioc aop ----------------------
ioc：在客户端调用一个类的方法 以往的作风 new 这个的实例 然后进行调用
现在是通过spring FactoryBean 利用工厂模式来创建的 这就叫控制反转
当一个类中调用另一个类中的方法 通过spring 容器 将另一个类的实例 注入到这个类中
创建类实例 利用FactoryBean 来完成 ---- 控制反转
通过spring 容器 将一个类的实例注入到另一个类中 ---- 依赖注入
aop： 面向切面编程
实现方式：1.动态代理 （一定需要接口）
2.cglib （不需要接口也可创建代理类）
三个切面（advisor）Regexp、names、defalut
五个通知
三个代理 ProxybeanFactory ----、、
BeanNemaAutoProxyCreator //可以为多个类创建代理 因为只要我们在beanNames 中注入bean的id。
DefaultAutoProxyCreator//他默认搜索所有的advisor 并且为所有的bean创建代理所以以为我
事物：分为jta 和jdbc
声明试和编程式
实现有五种方式
-------------------java基础---------------
-------------IO流--------------
IO流：字符流(字节 字符) 字符流每次读取16个字节单位的数据
字节流(只流字节) 字节流每次读取8个字节单位的数据
注：一个中文两个或多个字节
常见的IO类：
ByteArrayInputStream ----- 内存流---把信息存入内存中的一个缓冲区中
PipedInputStream -----管道流----实现了pipe的概念，主要在线程中使用
SequenceInputStream -----顺序连结流
ObjectInputStream -----对象流
BufferedInputStream -----缓存流
DataInputStream -----特殊流
PushbackInputStream -----回压流
FileOutputStream -----文件输入流-----把信息存入文件中
面试点：***************
-----------------------异常-----------------------
异常：java异常是java提供的用于处理程序程序中错误的一些异常事件。运行期出现的错误。
throwable：Errow(错误 不可恢复)
Exception(异常 可恢复)
Exception：系统异常(系统已写好)
自定义异常
也分为：检查性异常(Exception直接子类 必须捕获) 不检查性异常(runtime直接子类)
1.图
2.五个关键字：try catch finally throw throws
3.catch原则 先小的 后大的
4.异常与重写的关系
自定义异常的实现：自定义类实现RuntimeException接口 在本类的构造方法调父类的构造方法(super()) 并传入自定义内容 在另一类中直接抛出该类对象
常见的异常：
ArrayIndexOutOfBoundsException
ArrayStoreException
ClassNotFoundException
ClassCastException
IllegalAccessException
IllegalArgumentException
NullPointerException
----------------------------线程---------------------------
线程：线程从本质上说是一个正在执行的程序 它拥有自己独立的数据空间 占有一定的系统资源
线程与进程的关系：线程是进程的细分 它是进程内部的一个顺序控制流 有一个入口 一个出口 还有一个顺序执行序列
与进程不同的是 线程不能单独运行 必须依赖某个进程运行 统一进程中的所有线程共享进程所有的资源。
线程：守护线程
用户线程
线程的五种状态：新建 就绪 运行 阻塞(挂起) 终止(死亡)
创建线程的两种方式：继承Thread
实现runnable接口
比如：A a = new A(); Thread temp = new Thread(a); temp.start();
造成死锁的原因和解决方法：
原因：每条线程都调用了suspend方法 被挂起了 都等待着另一条线程调用resume 方法唤醒自己。
解决方法：
线程安全转化为线程不安全?
1.加synchronizd
2.调用sleep()方法。
3.调用wait()方法 再调用notify()方法；
---------------java.util-----------------
各个容器间的区别和联系
------------------补充----------------------
java 内置注解：
@Override
@Deprected
@SuppressWarning
java中实现多态的机制？
方法重写和方法重载
重写：是父类与子类之间多态性的一种表现
重载：是一个类中多态性德表现
对象的操作方法有哪些？
直接序列化 传参 返回值 数组 反射
对象序列化：
把一个对象任意时候的状态保存到web机制(外部文件)
反序列化：
web机制把对象的状态还原到对象中
-----缓存的作用
----------------反射---------------------
反射：Java提供了一套机制来动态执行方法和构造方法，以及数组操作等，这套机制就叫——反射
反射机制主要提供以下功能：
1.在运行时判断任意一个对象所属的类
2.在运行时构造任意一个类的对象
3.在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）
4.在运行时调用任意一个对象的方法（*****注意：前提都是在运行时，而不是在编译时）
例子：
创建实例：
1.Class c = Class.forname("xxxx"); // 得到一个类的class对象
Constractor con = c.getConstractor(String.Class); // 传入参数的class 对象
Stu stu = con.newInstance("xxxxxx"); // 传入参数 并 得到对象
2.Class c = Class.forName("xxxx");
Stu stu = (Stu)c.newInstance(); /// 得到对象
方法区别：
class 对象-----
getDeclaredConstractors(); // 本类的所有构造方法(包括private 修饰)
getDeclaredMethods(); // 得到本类的方法
getMethods(); /// 得到所有的方法(包括父类的)
XML： Extensible Markup Language
XML: 自定义标记语言
HTML: 固定标记语言
定义XML的方式：DTD
Schema
-----------------------------------XML的解析----------------------------------
-------dom4j 解析xml文件例子：-----------
Document document = null;
try
{
document = new SAXReader().read(filePath);// 得到document 对象
} catch (DocumentException e)
{
e.printStackTrace();
throw new GeneralException("Dom4j解析配置文件jdbc.xml出现异常！");
}
Element root = document.getRootElement(); //得到根节点对象
Iterator<Element> iter = root.elementIterator("db"); // 得到根节点下的所有元素
while(iter.hasNext()){
Element element = iter.next();
String type = element.elementText("type");// 拿到具体的值
}
---------SAX 解析xml文件例子---------
优点：
因此不需要将数据存储在内存中。
SAX 解析器采用了基于事件的模型 可以激活一个回调方法。
public class Ceshi extends DefaultHandler{ // 需要继承DefaultHandler 并实现里面的方法
public static void main(String[] args)
{
String filename = "WebContent/WEB-INF/ceshi.xml";
SAXParserFactory spf = SAXParserFactory.newInstance();
try
{
SAXParser saxParser = spf.newSAXParser();
saxParser.parse(new File(filename), new Ceshi());
}catch (){
}
在startElement 方法循环迭代出来
---------------------------ajax-------------------------------
创建一个ie 对象 判断为ie 或非ie
--------------------基础面试点---------------------
java.lang包
String，StringBuffer，StringBuild各自的含义的区别
截取字符串的编程题
反射(java reflection的定义和用法。
请问java下Class.forName的作用是什么，为什么要使用它
NEW了一个String对象问你这个共有几个对象
java.io包
java中有那几种流（最基础的）？
io和nio(new io)的区别以及nio的用法。
写一段程序，如何读取一个文件夹所有的文件和子文件夹的所有文件
java.io.Reader与java.io.InputStream的区别
什么是序列化？序列化的作用?
java.io.StringWriter,什么时候调用 他的flush方法,以及StringWriter的作用
java.net包
tcp和udp的区别？
socket怎么得到当前ip
通过Socket来编写一个聊天程序。
java.sql包
给你ip,数据库名，表名，密码要你将通过jdbc连接，并查出前100条数据的过程代码
请写出jdbc调用存储过程的代码
插入10万条数据用jdbc语句怎么写。
preparedstatement与statement的区别？
jdbc里你是怎么样进行批处理的。
java.util包
ArrayList,LinkedList和HashMap的各种比较,比如ArrayList 同 Vector的比较,HashMap同treeMap的比较, ArrayList同LinkedList的比较,数组和ArrayList的区别，List与Set区别，Set与Map区别；
简述HashMap原理，并画出它的结构图；
Collection和Collections的区别
线程
什么叫线程？谈谈你对多线程的理解
多线程有几种实现方法，都是什么?
sleep和wait区别？
java线程里的wait，sleep，synchronzied，notify分别有什么作用?
启动线程有那几种方式？
唤醒一个线程与唤醒所有线程的方法分别是？
有两个线程,一个线程每分钟把系统时间写入一个文件,另一个线程读出文件里的数据.
同步与异步的区别? 在什么情况下分别使用？同步的方法有哪些?
进程与线程的概念理解
线程的状态控制
设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
异常
EROOR与Exception的区别
------------------------------Ext----------------------------
Ext：ExtJs的简称 是一个强大的Js类库
ExtJs框架支持Ajax实现 通常 Ajax 应用程序的一个公用特征是应用程序可以异步的响应用户输入 它会刷新局部用户界面而不需要重新显示整个Web界面
ExtJs中基本组件体系：
基本组件
工具栏组件
表单及字段组件
基本组件：
box
button
component
container
panel
1.ext它提供了一套非常绚丽的UI，与后台无关的框架。
2.ext是一套开源的框架。
3.容器组件用来装组件的。
4.ext.form.FormPanel用来装表单组件的。
5.容器是用来装东西的(记好了)。
6.所有的表单组件都继承field组件。
7.组件(都是BoxComponent下面的组件):基本组件，工具栏组件（tbar下面的组件），表单组件(表单下面的组件)。
8.所有的组件销毁都是引用BoxComponent来的。
9.ext中一个组件代表一个类，要用组件直接new一个就可以，默认的情况下所有的组件都初始化了。
10.当对象指向rendering以后，每一个对象都对应一个DOM。
1.Ext的核心组件(component):自动支持了标准的隐藏，显示，启用，禁用等，Ext中每一个组件都对应着一个xtype属性，在Ext中xytpe直接可以创建组件，所有的组件都可以通过renderTo来进行渲染html页面。
2.组件的生命周期是:创建，初始化，销毁。
3.Ext.container有两个重要的属性:1.layout2.items。
4.页面布局都交给Viewport来管理。
5.Ext实用工具:1.onReady()
6.js中没有静态的，静态的就是一个函数。
7.get方法是获取HTML元素或者ext元素的一个函数，返回来的数据类型是Ext.element，必须通过id或者dom对象。
8.getCmp用来获得一个Ext组件。
9.getBody返回当前body的element。
10.borderLayout布局:把界面分成了5部分，东南西北中，中是一定要的(如果没有中，就报布局出错)。
-------------------------------------JQuery-----------------------
JQuery是一个类库 为web的javascript开发提供辅助功能
JQuery使用户能方便的处理HTMLdocument Event 实现动态效果并且方便的为网站提供ajax 交互。
优势：
文档说明很全 而且各种应用也说的很详细
很多成熟的插件
JQuery----->$
jquery的得值方式：
$("#id")[0].value() -----转化为DOM 元素取 debug调试发现
$("#id").val() -----直接调方法取
$(dom) DOM---->Jquery
------------------------------过滤器的使用-----------------
1.实现Filter接口 重写init() doFilter() destroy()方法
2.具体的操作
public class CharacterEncodingFilter implements Filter {
private FilterConfig config = null; //filet配置
private String encoding = "UTF-8"; // 默认字符编码
public void init(FilterConfig config) throws ServletException {
this.config = config;
this.encoding = config.getInitParameter("encoding");//web.xml配置参数
}
/**
* 字符处理方法
*/
public void doFilter(ServletRequest srequest, ServletResponse sresponse,
FilterChain chain) throws IOException, ServletException {
if (null != encoding) {
HttpServletRequest request = (HttpServletRequest)srequest;
HttpServletResponse response = (HttpServletResponse)sresponse;
// 对请求进行编码设置
request.setCharacterEncoding(encoding); //把请求用指定的方法编码
response.setContentType("text/html");
response.setCharacterEncoding(encoding); //把返回响应指定 编码方式
System.out.println("------------过滤编码-------------" + encoding);
}
// 把处理权限交给下一个过滤器
chain.doFilter(srequest, sresponse);
}
public void destroy() {
}
}
3.web.xml 配置
<filter>
<filter-name>filter</filter-name>
<filter-class>servlet.filter.filter</filter-class>
<init-param>
<param-name>encoding</param-name> ///可传参数
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>filter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
--------------------------DButil-----------------------------
解决的问题：
a、大量的重复代码
b、jdbc的简单封装
c、使用策略模式可以生成不同的返回类型
涉及技术：
a、反射
b、泛型
c、元数据
d、可变参数
缺点：没有进行事务处理
流程：
调用query 方法(具体的) ---->适配器模式兼容查询功能 预处理------->选择类型-------->创建bean 利用反射机制生成一个对象
用法：
1.定义一类：继承BasicDataSource 并定义一方法 用this 定义父类连结数据库的属性
public class LoginDataSource extends BasicDataSource{
public LoginDataSource() {
this.setDriverClassName("com.mysql.jdbc.Driver");
this.setUsername("root");
this.setPassword("123");
this.setUrl("jdbc:mysql://192.168.2.72/english?useUnicode=true&charactorEncodering=UTF-8");
}
}
2.得到QueryRunner 构造QueryRunner 有两种方法：无参 ，DataSource类型的参数 采用后一种
QueryRunner queryRunner= new QueryRunner(new LoginDataSource());
3.执行具体的SQL操作
queryRunner.query();
queryRunner.update();
.......
Connection connection = queryRunner.getDataSource().getConnection(); // 得到连结对象
---------------------UML--------------------------------------
UML：统一建模语言
UML为面向对象开发系统的产品进行说明、可视化、和编制文档的一种标准语言。
UML最适于数据建模，业务建模，对象建模，组件建模。
UML的内容：
(1) UML语义
描述基于UML的精确元模型定义。元模型为UML的所有元素在语法和语义上提供了简单、一致、通用的定义性说明，
使开发者能在语义上取得一致，消除了因人而异的最佳表达方法所造成的影响。此外UML还支持对元模型的扩展定义。
(2) UML表示法 标准建模语言UML的重要内容可以由下列五类图（共9种图形）来定义
第一类是用例图
第二类是静态图 (Static diagram)，
第三类是行为图（Behavior diagram），
第四类是交互图（Interactive diagram），
第五类是实现图 ( Implementation diagram )。
用例图的关系：包含关系：用例可以简单地包含其他用例具有的行为，并把它所包含的用例行为做为自身行为的一部分，这被称作包含关系
扩展关系：意外情况
类图的三种关系：关联：一个类的实例必须要用到另一类实例 才能完成工作叫关联
聚合：带菱形的连线
泛化：一个指向其他类作为超类的继承连线
--------------------------ubuntu 简单操作-------------------
touch ----->生成新的文件
sudo ----->设置密码
rm file --->删除文件
mkdir --->新建目录
加 -r --->删除目录
ls： --->清单
面试点：
rm命令可删除文件或目录，其主要差别就是是否使用递归开关 -r或-R 。
查看当前监听80端口的程序
lsof -i :80
查看当前有哪些进程
ps -A
查看当前的内存使用情况
free -l
查看CPU信息
cat /proc/cpuinfo
---------------------------CC 持续集成-----------------------
持续集成是一种软件开发实践 简称ci 可以让程序员持续不断的集成svn上的代码 是为了解决程序员手动检出svn上最新的代码的问题而出现
优点：
更容易发现bug 因为单独提供了一个单元测试的页面 自动的测试 并将测试结果反馈在页面上 自动 不间断的检测svn上的代码 并更新
安全性比较高
自动化程度比较高
缺点：配置文件过于复杂 特别是config文件
公司怎么用的：
首先下载一个cc工具 并配置环境变量 然后在dos命令中 检 出svn服务器 上的项目 并且在 config.xml文件进行项目的相关配置 比如项目名 和自动检测的间隔时间和延迟时间 如果有改动就及时更新 首先会找到build.xml文件 build文件首先清空以前的一些垃圾信息比如class文件和目录 然后执行预编译 将项目打包成jar 包 或者war 包 发布tomcat 中 就可以运行了
也可以对项目进行单元测试 和数据库集成 比如数据库集成 首先是对数据库进行清空和删除一些表信息 然后再初始化数据库一些文件信息 就可以持续不断的进行数据库集成了
经验就是：编译后的class文件要放在build 目录的下的class文件夹 并且junit的输入和ant 的输入路径相同 否则找不到测试类
首先是以config.xml文件为入口 并且找到 该项目的build 文件 并首先会清空里面原有的信息比如class文件 然后执行预编译 包括jar包和java文件 然后进行单元测试 和 对数据库进行一些初始化
同类框架比较：
更加自动化···
最佳实践：
经常提交代码
不要提交无法构建的代码
避免检出无法构建的代码
立即修复无法集成的构建
编写自动化测试
必须通过所有的测试和审查
执行私有构建
自动化构建
自动化数据库集成
使用本地数据库沙盒
执行单命令构建
创建一致的目录结构
及时的提交可构造的代码 保持svn上代码的正确性
自动化单元测试
自动化功能测试
自动化系统测试
自动化组件测试
svn检出：
先将ant有关的jar包导入 到cc工具中 因为eclipse 没有自带
然后配置 svn 的地址 用户名 密码等 连结属性
让后配置里面的 svn 节点的配置 就可以自动的检出svn上的代码了
---------------------------------spring事物配置----------------------------------
有五种：
第一种方式：每个Bean都有一个代理
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean>
<!-- 定义事务管理器（声明式的事务） -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 配置DAO -->
<bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="userDao"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<!-- 配置事务管理器 -->
<property name="transactionManager" ref="transactionManager" />
<property name="target" ref="userDaoTarget" />
<property name="proxyInterfaces" value="com.bluesky.spring.dao.GeneratorDao" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
lt;/beans>
所有Bean共享一个代理基类：
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean>
<!-- 定义事务管理器（声明式的事务） -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="transactionBase"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
lazy-init="true" abstract="true">
<!-- 配置事务管理器 -->
<property name="transactionManager" ref="transactionManager" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<!-- 配置DAO -->
<bean id="userDaoTarget" class="com.bluesky.spring.dao.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="userDao" parent="transactionBase" >
<property name="target" ref="userDaoTarget" />
</bean>
</beans>
第三种方式：使用拦截器：
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean>
<!-- 定义事务管理器（声明式的事务） -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<bean id="transactionInterceptor"
class="org.springframework.transaction.interceptor.TransactionInterceptor">
<property name="transactionManager" ref="transactionManager" />
<!-- 配置事务属性 -->
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>*Dao</value>
</list>
</property>
<property name="interceptorNames">
<list>
<value>transactionInterceptor</value>
</list>
</property>
</bean>
<!-- 配置DAO -->
<bean id="userDao" class="com.bluesky.spring.dao.UserDaoImpl">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
</beans>
第四种方式：使用tx标签配置的拦截器：
<context:annotation-config />
<context:component-scan base-package="com.bluesky" />
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml" />
<property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration" />
</bean>
<!-- 定义事务管理器（声明式的事务） -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="*" propagation="REQUIRED" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="interceptorPointCuts"
expression="execution(* com.bluesky.spring.dao.*.*(..))" />
<aop:advisor advice-ref="txAdvice"
pointcut-ref="interceptorPointCuts" />
</aop:config>
lt;/beans>
第五种方式：全注解：
-------------------------
长沙博赛软件有限公司
湖南省长沙市岳麓区景秀路2号
109路,117路,118路,132路,301路,301路区间,317路,318路,401路,804路
毕业院校：
北京科技师范学院 计算机科学与技术
北京科技师范学院创建于1980年
北京市大兴区黄村镇北程庄东路2号院
北京师范大学北校门的旁边
---------------------------------------经典面试----------------------------------
6、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
对于short s1 = 1; s1 = s1 + 1; 由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。
对于short s1 = 1; s1 += 1;由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。
内部类：
特征：在一个类的内部定义的类 其他类不能直接调用 不能定义静态变量 可以访问外部变量
Static Nested Class 和 Inner Class区别：
static Nested Class能访问外部类的非static成员变量。
关于return finally 执行顺序：
<jsp:userbean>中scope有哪几种类型? // scope ：作用域
page — bean只能在单一JSP页面中被访问，寿命期只存在于当前请求（即其为service方法中的局部变量）。
request — bean能在单一JSP页面及此页面include或forward的其他页面或servlet中被访问（即其为Request的属性）。---整个应用用的是同一个bean。 比如：页面刷新
session — bean能在特定用户会话中的所有JSP页面和servlet中被访问（即其为session的属性）。 ---- 这次会话中用的是同一个。
application — bean能在此web应用程序下的所有JSP页面和servlet中被访问（即其为Servlet context的属性）。----整个应用用的是同一个bean。
Cookie与Session的区别，Session的工作原理
Cookie:客户端保存用户信息
Session：服务端保存用户信息 安全性相对要高一些；
session：保存的是对象，cookie中保存的是字符串
通常session cookie是不能跨窗口使用的，当你新开了一个浏览器窗口进入相同页面时，
系统会赋予你一个新的sessionid，这样我们信息共享的目的就达不到了，此时我们可以先把sessionid保存在persistent cookie中，然后在新窗口中读出来，就可以得到上一个窗口SessionID了，这样通过session cookie和persistent cookie的结合我们就实现了跨窗口的session tracking（会话跟踪）。
43、try {}里有一个 return 语句，那么紧跟在这个 try 后的finally {}里的 code 会不会被执行，什么时候被执行，在 return 前还是后?
会执行，在 return 前执行。
如果再加个catch finally加个return语句 会执行后面那个return语句
简述synchronized和java.util.concurrent.locks.Lock的异同 ？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁
Collection 和 Collections的区别。
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
request.getAttribute() 和 request.getParameter()区别：
方式：
1.getParameter取值是基于Post和Get方式的传递的.(url 挂问号传递的值)
getAttribute取值是以编程的方式存储到WEB会话上下面中的，
例如：request.setAttribute("roleList", roleList);
类型：
2.getParameter的值没有类型或者看成是String类型的;
getAttribute的值是对象，可以是String已及用户自已定义的类型
11. jsp有哪些内置对象?作用分别是什么? 分别有什么方法？
答:JSP共有以下9个内置的对象：
request 用户端请求，此请求会包含来自GET/POST请求的参数
response 网页传回用户端的回应
pageContext 网页的属性是在这里管理
session 与请求有关的会话期
application servlet 正在执行的内容
out 用来传送回应的输出
config servlet的构架部件
page JSP网页本身
exception 针对错误网页，未捕捉的例外
request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
response表示HttpServletResponse对象，并提供了几个用于设置送回 浏览器的响应的方法（如cookies,头信息等）
out对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。
session表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息
applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息
config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
page表示从该页面产生的一个servlet实例
12. jsp有哪些动作?作用分别是什么?
（这个问题似乎不重要，不明白为何有此题）
答:JSP共有以下6种基本动作
jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记
16、页面间对象传递的方法
request，session，application，cookie等
7.分页语句
取出sql表中第31到40的记录（以自动增长ID为主键）
sql server方案1：
select top 10 * from t where id not in (select top 30 id from t order by id ) orde by id
sql server方案2：
select top 10 * from t where id in (select top 40 id from t order by id) order by id desc
mysql方案：select * from t order by id limit 30,10
oracle方案：select * from (select rownum r,* from t where r<=40) where r>30
集合类的排序 提示：可实现comparable 接口：
两种：
1.对象本身实现Comparable接口,那么该类的实例就是可以排序的.
只要实现了Comparable接口,就可以调用Collections的sort方法对集合中的元素排序.
TestList // list 排序
TestMap // map 排序
class TestBean{
private int count;
private String name;
public void toString(){
return count+"\t"+name;
}
}
class TestComparator implements Comparator{
public int compare(TestBean o, TestBean oo) {
if(o.count==oo.count){
return 0;
}else if(o.count>oo.count){
return 1;
}else{
return -1;
}
}
}
TreeSet tree=TreeSet(new TestComparator());
tree.add(new TestBean());
2.指定一个Comparator,也就是实现了Comparator的类的一个实例.
但是Java本身只提供了一个Comparator的实现,就是Collections.reverseOrder().
该方法返回的是一个已经实现了Comparable接口的反序.
--------------------待整理进去的内容-------------------------------------
pageSize=20;
pageNo = 5;
1.分页技术1（直接利用sql语句进行分页，效率最高和最推荐的）
mysql:sql = "select * from articles limit " + (pageNo-1)*pageSize + "," + pageSize;
oracle: sql = "select * from " +
"(select rownum r,* from " +
"(select * from articles order by postime desc)" +
"where rownum<= " + pageNo*pageSize +") tmp " +
"where r>" + (pageNo-1)*pageSize;
注释：第7行保证rownum的顺序是确定的，因为oracle的索引会造成rownum返回不同的值
简洋提示：没有order by时，rownum按顺序输出，一旦有了order by，rownum不按顺序输出了，这说明rownum是排序前的编号。如果对order by从句中的字段建立了索引，那么，rownum也是按顺序输出的，因为这时候生成原始的查询结果集时会参照索引表的顺序来构建。
sqlserver:sql = "select top 10 * from id not id(select top " + (pageNo-1)*pageSize + "id from articles)"
4、你对Spring的理解。
1.Spring实现了工厂模式的工厂类（在这里有必要解释清楚什么是工厂模式），这个类名为BeanFactory（实际上是一个接口），在程序中通常BeanFactory的子类ApplicationContext。Spring相当于一个大的工厂类，在其配置文件中通过<bean>元素配置用于创建实例对象的类名和实例对象的属性。
2. Spring提供了对IOC良好支持，IOC是一种编程思想，是一种架构艺术，利用这种思想可以很好地实现模块之间的解耦。IOC也称为DI（Depency Injection），什么叫依赖注入呢？
譬如，Class Programmer
{
Computer computer = null;
public void code()
{
//Computer computer = new IBMComputer();
//Computer computer = beanfacotry.getComputer();
computer.write();
}
public void setComputer(Computer computer)
{
this.computer = computer;
}
}
另外两种方式都由依赖，第一个直接依赖于目标类，第二个把依赖转移到工厂上，第三个彻底与目标和工厂解耦了。在spring的配置文件中配置片段如下：
<bean id=”computer” class=”cn.itcast.interview.Computer”>
</bean>
<bean id=”programmer” class=”cn.itcast.interview.Programmer”>
<property name=”computer” ref=”computer”></property>
</bean>
3. Spring提供了对AOP技术的良好封装， AOP称为面向切面编程，就是系统中有很多各不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，例如，加入日志，加入权限判断，加入异常处理，这种应用称为AOP。实现AOP功能采用的是代理技术，客户端程序不再调用目标，而调用代理类，代理类与目标类对外具有相同的方法声明，有两种方式可以实现相同的方法声明，一是实现相同的接口，二是作为目标的子类在，JDK中采用Proxy类产生动态代理的方式为某个接口生成实现类，如果要为某个类生成子类，则可以用CGLI B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法，系统功能的代理以Advice对象进行提供，显然要创建出代理对象，至少需要目标类和Advice类。spring提供了这种支持，只需要在spring配置文件中配置这两个元素即可实现代理和aop功能，例如，
<bean id=”proxy” type=”org.spring.framework.aop.ProxyBeanFactory”>
<property name=”target” ref=””></property>
<property name=”advisor” ref=””></property>
6、四种会话跟踪技术
会话作用域ServletsJSP 页面描述
page否是代表与一个页面相关的对象和属性。一个页面由一个编译好的 Java servlet 类（可以带有任何的 include 指令，但是没有 include 动作）表示。这既包括 servlet 又包括被编译成 servlet 的 JSP 页面
request是是代表与 Web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件（由于 forward 指令和 include 动作的关系）
session是是代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常会跨越多个客户机请求
application是是代表与整个 Web 应用程序相关的对象和属性。这实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域
-----------------------------ibatis------------------------------
1.ibatis中 # 跟 $的区别？
select * from member where id =#id# ------ 适用于传参问题 可以直接传属性值 也可以传javabean ibatis会自动解析
问题：iBATIS默认会把“#”中间的变量作为字符串来处理
解决问题：
使用$将你的变量括起来，iBATIS不会给这个变量做任何的处理，直接生成你要的SQL
简单的说：
使用#号传值 ibatis默认会把#号中间的变量作为字符串来处理。
使用$号传值 ibatis不会给这个变量做任何处理 直接生成你想要的SQL。
$方式一般用于传入数据库对象．例如传入表名;
一般能用#的就别用$ ; 性能问题吧
2.Ibatis中使用like ‘%#filedName#%’ 时，有什么问题？
在xml映射文件中，如果直接按如上写法，会报异常：java.sql.SQLException: Invalid argument in JDBC call: parameter index out of range: 1。
所以一般会采用如下两种方式：
1) 将#换成$，如like ‘%$ filedName $%’，这样就没有问题了..
2) 采用字符串联接符||，如：like ‘%’||# filedName #||’%’
与hibernate相比较：
难易度：a.更容易掌握
SQL:b.更容易进行SQL优化， hibernate的自动生成的sql 有点难看。
c.可以进行细度的优化
1.比如我要查询一个表中的一个或几个字段 直接一个sql 搞定 而hibernate利用面向对象的方式会将所有的数据查出来 就浪费的内存
效率：不考虑hibernate的缓存的话 ibatis的效率要高一些。
可维护性：个人觉得ibatis要好一些。ibatis 的sql 单独保存到一个文件中 易于维护 而hibernate在java代码中保存sql
hibernate的优点：对数据库类型兼容比较好
自动化程度比较高
还得根据不同需求选择不同数据库。
------------------------------WebService-------------------------------
解决了什么问题：
在以往传统应用程序中 采用独立的进程模式 这些应用程序之间没法进行真正通信，彼此间不能共享数据 而Webservice正好解决了一些问题。
Web services（也称web 服务技术）是一种面向服务的架构技术，是一种进行分布式部署和应用的流行方式，通常用来建立可互操作的分布式应用程序
简单地说，Web services就是一个应用程序，它向外界暴露出能够进行远程调用的接口程序。
一种思想 一种架构
一种 SOA 架构 : 面向服务架构
webservicer 的框架：axis1 axis2 xfire cxf
怎么用的？
我用的是axis2 框架
a.浏览器访问：
1.首先是下载----它是apache公司的一个开源框架。
2.解压axis2.war ，然后部署到tomcat/webapps目录下
3.利用POJO实现零配置的WebService
4.编写POJO --- 就是定义一个类和几个方法
5.SimpleService.class文件放到<Tomcat安装目录>\webapps\axis2\WEB-INF\pojo目录中（如果没有pojo目录，则建立该目录）
6.访问：http://localhost:8080/axis2/services/listServices 也可以直接在url 后面带参数过去
b.使用RPC方式调用web service
1.// RPC客户端服务类
RPCServiceClient serviceClient = new RPCServiceClient();
Options options = serviceClient.getOptions();
2.// 指定调用web service的URL
String url = "http://localhost:9090/axis2/services/SimpleService";
EndpointReference taretRef = new EndpointReference(url);
options.setTo(taretRef);
3.// 指定getGreeting方法的返回值的数据类型的calss对象
Object[] opsArgs = new Object[] { "和尚" };
Class[] returnTypes = new Class[] { String.class };
// 指定要调用的getGreeting方法及其WSDL文件的命名空间
QName qName = new QName("http://ws.apache.org/axis2", "getGreeting");
4.调用
System.out.println(serviceClient.invokeBlocking(qName, opsArgs,returnTypes)[0]);
----------------------------------- SSH 框架整合 ------------------------------------------
web.xml 配置文件
<！利用监听器初始化spring 的配置文件applicationContext.xml文件 实现依赖注入 >
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<！struts 的配置>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<！路径拦截>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>
applicationContext.xml 配置文件 spring
<!-- 配置dataSource 数据库连接 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql:///hibernate"></property>
<property name="username" value="root"></property>
<property name="password" value="123"></property>
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="hibernateProperties">
<props><!-- 一些属性 比如sql 可见 自动创建表 -->
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<property name="mappingResources">
<list><!-- 初始化javabean映射文件 -->
<value>com/lxit/ssh/bean/person.hbm.xml</value>
</list>
</property>
</bean>
<!-- 一般的spring注入 -->
<bean id="personDao" class="com.lxit.ssh.dao.PersonDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property><!-- hibernate模板需要注入sessionFactory -->
</bean>
<bean id="personService" class="com.lxit.ssh.service.PersonServiceImpl">
<property name="personDao" ref="personDao"></property>
</bean>
<bean name="personAction" class="com.lxit.ssh.web.PersonAction">
<property name="personService" ref="personService"></property>
</bean>
person.hbm.xml----javabean映射配置文件
<hibernate-mapping package="com.lxit.ssh.bean" >
<class name="Person" >
<id name="id">
<generator class="uuid.hex"></generator>
</id>
<property name="name" ></property>
<property name="age" ></property>
</class>
</hibernate-mapping>
---------------------------spring ioc aop ----------------------
ioc：在客户端调用一个类的方法 以往的作风 new 这个的实例 然后进行调用
现在是通过spring FactoryBean 利用工厂模式来创建的 这就叫控制反转
当一个类中调用另一个类中的方法 通过spring 容器 将另一个类的实例 注入到这个类中
创建类实例 利用FactoryBean 来完成 ---- 控制反转
通过spring 容器 将一个类的实例注入到另一个类中 ---- 依赖注入
aop： 面向切面编程
实现方式：1.动态代理 （一定需要接口）
2.cglib （不需要接口也可创建代理类）
三个切面（advisor）Regexp、names、defalut
五个通知
三个代理 ProxybeanFactory ----、、
BeanNemaAutoProxyCreator //可以为多个类创建代理 因为只要我们在beanNames 中注入bean的id。
DefaultAutoProxyCreator//他默认搜索所有的advisor 并且为所有的bean创建代理所以以为我
事物：分为jta 和jdbc
声明试和编程式
实现有五种方式
扫一扫
1826
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
