操作xml|json|以及框架的简单介绍

//操作JSON
//把list对象装换为Json格式
List list=new Arraylist();
list.add();
//普通类型、List、Collection都是用JSONArray解析
JSONArray json=JSONArray.fromObject(list);
//Map、自定义类型使用JSONObject解析
JSONObject jsonObject=JSONObject.fromObject(Map|自己定义的类型); J
//向Json中装入数据
json.put("field1","field2");
String variable=json.get(index).toString();
String variable2=json.getString("");
//把json装换为字符串
String jsons=json.toString();

//使用百度提供的工具操作json
Gson gson = new Gson();
List list=new ArrayList();
list.add()
.....
String str=gson.toJson(list);
//JSon字符串转换为对象
List<> li=gson.fromJson(str,Student.class);
//在jquery中解析JSON
function loadInfo{
$.getJSON("URL",function(/**该方法是请求成功后的回调函数*/ date /**data是返回的JSON对象
*/){
$.each(data.comments,function(i,item){//data.comments是Json数组。i是遍历的index，item遍
历的值
$(‘#info’).append(
"<div>"+item.id+"</div>"+
.............
)
});
});
}
//操作ＸＭＬ
//定义一个DOM解析器工厂实例
DocumentBuildFactory factory=DocumentBuildFactory.newInstance();
DocumentBuilder dom=factory.newDocumentBuilder();
File file=new File("XXXXXXX");
Document doc=dom.parse(file);
Element root=doc.getDocumentElement();
NodeList nodeList=root.getChildNodes();
for(int i=0;i<nodeList.getLength();i++){
Node stu=nodeList.item(i);
Element stuElement=(Element)stu;
system.out.print(stuElement.getAttribute("field"));
//使用dom4j操作xml文件
将字符串装换为XML文件
String xmlStr=""
Document document=DocumentHelper.parseText(xmlStr);
Element root=document.getDocumentElement();
Node node=nodeList.item(i);
Element el=(Element)node;
el.getAttribute("");
//将XML文件转换为字符串
SAXReader reader=new SAXReader();
Document doc=reader.read("文件名")
String text = doc.asXML();
//在jquery中使用ajax
<form id='test'>
<input type='submit' value="提交">
</form>
<script>
var sub=$('#test').submit(function(){
$.ajax({
url:
cache:false,
type:'GET'|'POST',Tohoma; font-size:14px; line-height:22px"> date:{"userName":userName,Tohoma; font-size:14px; line-height:22px"> "loginName":loginName,Tohoma; font-size:14px; line-height:22px"> "password":password_f,Tohoma; font-size:14px; line-height:22px"> "orgId":orgId,Tohoma; font-size:14px; line-height:22px"> "userRole":userRole,Tohoma; font-size:14px; line-height:22px"> "phoneNum":phoneNum
}
success:function(data){//返回来的结果
var obj=eval('('+data+')');//将数据装换为json格式
}
</script>
JDBC操作步骤:
加载驱动（Class.forName("org.gjt.mm.MysqL")）
通过驱动管理器创建连接对象，DriverManage.getConnection();
通过连接对象，创建statement对象。
使用statement对象对数据库进行操作。
关闭connection对象和statement对象
JDBC缺点：
开发效率低
代码冗余
非面向对象
重复性工作多
容易出现sql安全问题
hibernate的核心
ORM（对象关系映射）:核心是生成 sql语句。它是为了解决面向对象鱼关系数据库存在的互不匹配现象的
技术。
为了完成ORM操作，需要描述对象与数据库表之间的关系，包括类与表的映射、对象属性与字段的映射、
主键与对象属性的映射等。
映射的方式:Annotation\xml方式
Annotation是对程序的注解
hibernate的开发过程：
1、部署必要的jar包
这里就不一一举例了。
2、在工具中添加hibernate支持、创建主配置文件hibernate.cfg.xml文件\
3、配置hibernate.cfg.xml文件(该文件里面包括：配置数据库连接、运行时需要的属性)
eg:
<property name="dialect">//这里代表方言的意思
org.hibernate.dialect.Oracle9Dialect
</property>
<property name="connection.url">//地址
jdbc:oracle:thin:@10.0.0.188:1521:ORCL
<property name="connection.username">jbit</property>
<property name="connection.password">bdqn</property>
<property name="connection.driver_class">//驱动
oracle.jdbc.driver.OracleDriver
操作过程中，所有的实体对象必须实例化。
添加映射文件
这里采用的是xml进行映射
如:Student.hbm.xml
<hibernate-mapping>
<class name="com.phome.entity.Student" table="student">
<id name="stuId" column="stuid">
<generator class="increment"></generator>//每次把主键加1，一般在这个地方使用
native让数据库自己去处理
</id>
<property name="stuName" column="name"></property>
<property name="stuAge" column="age"></property>
</class>
</hibernate-mapping>
在hibernate.cfg.xml文件里面配置
<session-factory>
<property name="show_sql"></property>//显示 sql语句
<property name="format_sql"></property>//格式化显示的sql语句
<mapping resource="com/phome/Student.hbm.xml"></mapping>
</session-factory>
hibernate的配置结束，接下来是操作数据库：
一共分为一下几个步骤：
1、读取并解析配置文件
Configuration conf=new Configuration().configue();
2、读取并解析映射信息，创建sessionFactory
SessionFactory factory=conf.buildSessionFactory();
3、打开session
Session session=factory.openSession();
4、开始事务（一般操作单条数据的时候不需要）
Transaction tx=session.beginTransaction();
5、数据库操作
session.save(object);
6、提交事务
tx.commit();
7、关闭session
session.close();
其中：SessionFactory需要读取Hibernate主配置文件，获取数据库连接所必要的条件。它是创建
session的容器。
session对JDBC中一系列对象的进一部封装。它可以操作数据库中的数据。
hibernate的执行过程：
1、产生Session对象
2、产生实体对象
3、操作数据库
4、提交或者回滚事务
5、关闭session
hibernate中实体的三种状态：
自由态（刚创建出来，还没有持久化，不处于session的缓存中）
持久态（已经持久化，在session缓存中存在）
游离态(已经持久化，但是在session缓存中不存在)
session中的方法：
load是懒加载，get是立即加载。
merge操作后，对象依然是游离态。
如果session中存在两个主键值相同的对象，调用saveOrUpdate操作时会出现异常。
hibernate查询：HQL查询、Criteria查询、本地sql
使用HQL的步骤
Configuration cf=new Configuration.configure();
SessionFactory sf=cf.buildSesssionFactory();
Session session=sf.openSession();
String hql="XXXXXXXXXXXXXX";
Query query=session.createQuery(hql);
List<T> list=query.list();
在hibernate中提供了两种缓存：一级缓存、二级缓存。
一级缓存：在Session中实现。当关闭session时一级缓存就消失。
二级缓存：在SessionFactory中实现，同一个SessionFactory的所有Session实例共享。
配置二级缓存：在hibernate.cfg.xml中添加
<property name="hibernate.cache.provider_class">
net.sf.ehcache.hibernate.EhCacheProvider
</property>
在ClassPath下创建ehcache.xml文件
<ehcache>
<diskStore path="java.io.tmpdir"/>
<defaultCache
maxElementsInMemory="10000“ 缓存中最大允许保存的对象数量
eternal="false“ 缓存中数据是否为常量
timeToIdleSeconds="120“ 缓存数据钝化时间，单位为秒
timeToLiveSeconds="120“ 缓存数据生存时间，单位为秒
overflowToDisk="true“ 内存不足时，是否启用磁盘缓存
/>
</ehcache>
在hibernate映射文件里面配置：
<class name="com.phome.Student" table=“student">
<cache usage=“read-only”/> 使用缓存
</class>
Spring
IOC(依赖注入) ：在程序运行前，将需要依赖的对象以及对象之间的关系初始化完毕。
优点：降低对象之间的耦合。依赖注入的方式：set注入、构造方法注入、对象注入、值注入、集合注入。
Bean的生命周期：
实例化bean对象、设置对象属性、设置相关依赖、回调init-method方法、使用bean对象、回到destory方法。
spring中bean的注解：@Componet（组件）、@Repository(仓库)、@Service(业务)、@Controller(控制器)
AOP（面向切面编程）
spring与hibernate的整合：
实际上就是把hibernate里面的dateSource\sessionFactory交给spring管理。网上教程很多： http://blog.csdn.net/ufoer23/article/details/314479
Struts2
优点：是一种无入侵式设计。
struts2最核心的就是拦截器，自身就是由一堆的拦截器组成。
Struts2在MVC架构中，充当控制器的作用。使用package将path与action映射。
struts2搭建流程
1、添加支持
2、编写配置文件
1、包级别result
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
" http://struts.apache.org/dtds/struts-2.0.dtd ">
<struts>

<constant name="struts.i18n.encoding" value="UTF-8"/>

<constant name="struts.serve.static.browserCache" value="false"/>

<constant name="struts.configuration.xml.reload" value="true"/>


<package name="user" namespace="/struts" extends="strus-default">
<global-results>
<result name="error">/error.jsp</result>当Action类的业务方法返回值是error的
时候，转向/error.jsp视图。
</global-results>
<action name="save" class="com.phome.action.saveAction" method="save">
<result name="success">/WEB-INF/page/success.jsp</result>
<package>
</struts>
2、全级别Result
<constant name="struts"
<package name="lala" extends="struts-default">
<global-result>
<result name="error">/error.jso</result>
</global-result>
<package name="lala11" namespace="student" extends="lala">
<action name="save" class="com.phome.action.SaveAction" method="save">
<result name="success">/index.jsp</result>
</action>
</package>
<package name="lala12" namespace="student" extends="lala">

<action name="delete*" class="com.phome.action.DeleteAction" method="delete">
<result name="success">/manage.jsp</result>
3、在web.xml文件中配置启动
<filter>
<filter-name>
strus2
</filter-name>
<filter-class>
org.apache.strus2.dispatcher.ng.filter.StrusPrepareAndExecuteFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>strus2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
4、定义Action
......
public String save(Student student){
.......
return success;
}
5、定义视图 (success.jsp)
Struts2的请求流程：
StrutsPrepareAndExecuterFilter是Struts2的核心，它负责拦截由配置文件中指定的用户的请求。当用
户请求达到是，它会过滤用户的请求，如果请求路径符合配置的话，会转入struts2框架处理。当转入
struts2框架的时候，会经过一系列的拦截器，然后到达action.Struts2对用户的每次请求都会创建一个
Action,所以Struts2中的线程是安全的。
struts2中获取参数的方法：
在struts2中没有request对象，但是替代它的是ServletActionContext类（能够获取内置对象）和
ActionContext类(能够像范围中保存数据)。
SHH整合
步骤：
1、添加jar包
2、添加数据库连接信息（dbconfig.properties）
driverClass=com.MysqL.jdbc.Driver
jdbcUrl=jdbc:MysqL://localhost/.....
user=root
password=root
maxPoolSize=30//最大存放30个连接对象
initialPoolSize=5//每次初始化5个连接对象
3、添加spring配置文件(创建applicationContext.xml文件\导入c3p0.jar)

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:dbconfig.properties</value>
</list>
</bean>

<beanid="c3p0DataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
<propertyname="driverClass"value="${driverClass}"/>
<propertyname="jdbcUrl"value="${jdbcUrl}"/>
<propertyname="user"value="${user}"/>
<propertyname="password"value="${password}"/>
<propertyname="maxPoolSize"value="${maxPoolSize}"/>
<propertyname="initialPoolSize"value="${initialPoolSize}"/>
</bean>

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionfactorybean">

<propertyname="dataSource"ref="c3p0DataSource"/>

<propertyname="mappingResources">
<list>
<value>com/phome/po/Grade.hbm.xml</value>
<value>com/phome/po/Student.hbm.xml</value>
</list>
</property>

<propertyname="hibernateProperties">
<value>
hibernate.dialect=org.hibernate.dialect.MysqLDialect
hibernate.show_sql=true
hibernate.format_sql=true
</value>

<bean id="template"class="org.springframework.orm.hibernate3.HibernateTemplate">

<propertyname="sessionFactory" ref="sessionFactory"/>

<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<propertyname="sessionFactory"ref="sessionFactory"></property>

<tx:annotation-driventransaction-manager="transactionManager"/>


<context:component-scanbase-package="com.phome"/>

<context:annotation-config/>
4、添加struts配置文件(设置将Action交给spring管理)

<constantname="struts.objectFactory" value="spring"/>
<packagename="student"namespace="/stu"extends="struts-default">
<action name="list*" class="com.phome.struts2.actions.StudentAction"method="list">
<result>/list.jsp</result>
</package>
5、配置web.xml文件（需要启动struts2和spring容器）

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>

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

<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
</filter-class>
</filter>
<url-pattern>/*</url-pattern>
配置完成，在实际开发中。需要注意@service\@reposity\controller上个注解。
面试复习1:
重载与重写的区别：
重载：让类以统一的方式处理不同类型的数据的一种手段。它是类中多态性的一种表现。
重写:子类继承父类，为了实现某些功能而对现有方法的重写定义。他是子类与父类之间多态性的一种表现。
他们都是实现多态性的表现。
序列化是用来处理对象流的机制，对象流可以用来在网络中传输。它是为了解决对象流在进行读写的过程中发生的问题。
struts2的请求过程：
当用户发出http请求的时候，根据web.xml配置，该请求被filterDispatch接收。根据struts.xml配置文件找到响应的Action和类,通过IOC，将值注入给action.action调用逻辑组件处理逻辑
业务这里包含数据的验证。action执行完毕后，更加它返回的结果跳转到相应的界面。
hibernate的请求过程：
1、读取并解析配置文件。
2、读取并解析配置文件里面的信息。
3、创建sessionFactory对象
4、利用sessionFactory对象创建session对象
5、开启事务
6、使用session持久化对象
7、提交事务
8、关闭session和sessionFactory
spring
它是许多第三方插件的集合体，里面主要包含的东西是AOP和IOC
代理分为：
动态代理（根据每个具体类编写响应代理类|针对一个接口编写一个代理类）
静态代理
其中AOP是面向切面编程，就是像把日志、持久性等东西切入进应用程序的代码中。
AOP的主要原理是：动态代理。
其中IOC是依赖注入，就是创建一个可以构造对象的容器，然后向这些对象传递他们的协作对象。
使用spring的目的：让对象与对象之间的关系不再通过代码来关联，而是通过配置类说明管理的。
http://wenku.baidu.com/link?url=pmlx67KZA2m6T5xPfzDXFwEydPPdavRBsZsW492b2i1ByFZNo5PlKFpYBj5-aMF1lUgWCEFiT_NEwC8f5zwBhS0k5_mxCEF3G6WYs6UX6wm
面试复习2
OOP的基本思想：把组件的实现和接口分离，并让组件具有多态性。
//操作json的使用
在json中jsonObject与jsonArray区别：
JSONObject是一个{}包裹起来的一个对象(Object)，而JSONArray则是[]包裹起来的一个数组(Array)。
//org.json下
把list集合转换成json
list.add(数据);
//向json中装入数据
json.put("键","值");
String var=json.get(index).toString();
Stirng var1=json.getString("键");
//将json转换成String
String js=json.toString();
//com.google.gson下<对象>
GsonBuild build=new GsonBuild();
Gson gson=build.create();
//以上两行可以写成
Gson gson=new Gson();
//将JavaBean转换为json字符串
String gBean=gson.toJson(对象);
//将json字符串转换为JavaBean
JavaBean bean=gson.fromJson(gBean,JavaBean.class);
//com.google.gson下<集合>
//指定集合属性
Type type=new TypeToken<list<UserBean>>(){}.getType();
//将集合转换为json字符串
String beanListToJson=gson.toJson(beanList,type);
//将json字符串转换为集合
list<UserBean> testBeanListFromJson=gson.fromJson(beanListToJson,Tohoma; font-size:14px; line-height:22px">JDBC的操作步骤：
1、加载驱动管理器DriverManage。
2、使用驱动管理器创建连接对象。
3、使用连接对象创建statement对象。
4、使用statement对象操作数据库。
5、关闭资源。
jdbc操作MysqL 数据库代码
Class.forName("org.MysqL.jdbc.Driver");
Connection connect=DriverManager.getConnection("jdbc:MysqL://localhost:3306/库名"，"用户名","密码");
Statement statement=connection.createConnection();
String sql="update xxx set field1 ="+var1+",field2="+var2+" where field3 ="+var3+"";
int j=statement.executeUpdate(sql);
Sting sql1="select * from xxx";
ResultSet rs=statement.executeQuery(sql1);
while(rs.next()){
string name=rs.getString("name");
int age=rs.getInt("age");
class.forName("org.MysqL.jdbc.Driver");
Connection conn=DriverManager.getConnection("jdbc:MysqL://localhost:3306/库名","用户名",Tohoma; font-size:14px; line-height:22px">Statement statement=conn.createStatement();
string sql="";
int i=statement.executeQuery(sql);
statement.close();
conn.close();
//使用SAXReader将XML文件转换为字符串
Document doc=new Document(file);
String text=doc.asXML();
hibernate的使用流程：
Configuration conf=new Configuration().configure();
2、读取并解析映射文件。
4、开始事务
Transaction ts=session.beginTransaction();
5、操作数据库
ts.commit();
7、关闭资源
hibernate
ORM的核心：生成 sql语句。
完成ORM操作需要描述对象和数据库表之间的关系，包括类与表之间的关系、类与表之间的映射、对象属性与字段的映射，主键与对象属性的映射等。
hibernate使用流程
Configuration conf=new Configuration.configure();
2、读取并解析映射文件
4、启动事务
Transaction ts=new Transaction();
hibernate中的三种状态
游离态（已经持久化，但是与session没有关联）、自由态(刚创建出来，没有持久化，与session没有关联)、持久态（已经持久化，与session有关联）。
hibernate中提供了两种缓存：
1、一级缓存（在session中实现，关闭 session时一级缓存就消失）。
2、二级缓存（在sessionFactory中实现，同时一个sessionFactory的所有session实例共享）。
在spring里面主要的内容是IOC与AOP
IOC(依赖注入)：在程序运行之前，将需要依赖的对象以及对象之间的关系都完成初始化。
实质：它就相当于是一个生产和管理bean的容器，原来需要new的东西，现在都交给IOC来完成。
非单例bean：每次调用都生产一个新的bean。
单例bean:与非单例相反。
依赖注入的方法：
1、set注入。
2、注解注入。
3、构造方法注入。
AOP（面向切面编程）：将程序中的交叉业务逻辑封装成一个切面，然后注入到目标中去。
实质：调用某个方法之前和之后，自动执行一系列自定义语句。
struts2的工作流程：
StrutsPrepareAndExecuteFilter是struts2的核心，它负责拦截由配置文件中指定的用户请求。
当用户请求达到的时候，StrutsPrepareAndExecuteFilter会获取请求。如果请求符合配置的话，会将请求交给struts2框架进行处理。当进入struts2框架之前会经过一系列的拦截器，然后到达指定的action。struts2会对用户的每次请求都创建一个action。
当用户请求达到时，由StrutsPrepareAndExecuteFilter拦截用户请求。当用户请求与配置文件符合时。会将用户请求交给struts2框架，在进入框架之前会经过一系列的拦截器。然后进入到指定的action。struts2会为每一个请求创建一个action。
在struts2中没有 request对象，但是它有ServletActionContext类。它可以获取内置对象。
HashTable与HashMap的区别：
HashMap是非线程安全的，HashTable是线程安全的。
HashMap可以让null保存在实体的键值对中，而hashTable是不允许的。
HashTable的方法是sychronize的，在多线程访问HashTable的时候，不需要为它的方法实现同步。而HashMap则需要为其实现同步方法。
同步和异步的区别，在什么情况下使用：
如果数据在多个线程之间共享，就需要使用到同步。
如果应用程序在对象上调用了一个需要花费很长时间来执行的方法，不希望让程序等待的时候，可以采用异步。
栈是采用先进后出的一个线性集合，而堆是栈的一个组成单元。
数据连接池的工作机制：
当java服务器启动的时候，会创建一定数量的池连接，并一直维持不少于此数目的池连接。客服端需要连接时，池驱动程序会返回一个未被使用的池连接并将其标记为忙。如果当前没有空闲的池连接，池驱动程序就会新建立一定数量的池连接。当使用的池连接调用完后，池驱动程序将会回收，并为其标记为空闲。
equal比较的是内容，而==比较的是地址。
垃圾回收机制：分代复制垃圾回收、标记垃圾回收、增量垃圾回收。
线程是指程序运行时，可以执行代码的一个单位。每个程序都至少有一个线程。线程的状态：运行、就绪、挂起、结束。
通过调用system.gc()方法主动通知虚拟机进

操作xml|json|以及框架的简单介绍

猜你在找的XML相关文章