操作xml|json|以及框架的简单介绍
发布时间：2020-12-16 09:25:09 所属栏目：百科 来源：网络整理
导读：//操作JSON //把list对象装换为Json格式 List list=new Arraylist(); list.add(); //普通类型、List、Collection都是用JSONArray解析 JSONArray json=JSONArray.fromObject(list); //Map、自定义类型使用JSONObject解析 JSONObject jsonObject=JSONObject.fr
|
//操作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操作，需要描述对象与数据库表之间的关系，包括类与表的映射、对象属性与字段的映射、 主键与对象属性的映射等。 映射的方式:Annotationxml方式 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里面的dateSourcesessionFactory交给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> <!--配置WEB应用默认的编码集，以后就不需要再在每个界面中去写HttpServletRequest的 setCharacterEncoding方法了--> <constant name="struts.i18n.encoding" value="UTF-8"/> <!--设置是否缓存静态内容，默认为true。开发阶段最好关闭--> <constant name="struts.serve.static.browserCache" value="false"/> <!--struts配置文件修改后，系统是否自动重新加载该文件，默认值为false，开发阶段最好打 开--> <constant name="struts.configuration.xml.reload" value="true"/> <!--注意包名虽然可以任意取，但是必须要唯一。namespace就是之后请求的路径，该例子中请 求路径为/struts/save.action。namespace可有可无。--> <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><!--这里默认会有个 type="dispatcher" type里面的值还有：redirect 重定向的方式跳转。redirectAction 重定向的方 式跳转到其他的Action中 chain 使用请求转发的方式跳转到其他的Action中--> <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"> <!--使用通配符，请求路径可以是这样子 的/student/deleteStudent|/student/deleteTeacher--> <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><!--* 可以表示多种后缀，如.action,.do。这里也可以是 do/action，根据自己喜欢的方式定义--> </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> <!--配置sessionFactory--> <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> <!-- 配置template，并注入sessionFactory |HibernateTemplate提供非常多的常用方法来完成基本的 操作，比如通常的增加、删除、修改、查询等操作--> <bean id="template"class="org.springframework.orm.hibernate3.HibernateTemplate"> <!-- 注入sessionFactory --> <propertyname="sessionFactory" ref="sessionFactory"/> <!-- 配置事务管理器 --> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <propertyname="sessionFactory"ref="sessionFactory"></property> <!-- 打开事务驱动器 --> <tx:annotation-driventransaction-manager="transactionManager"/> <!-- 配置bean的注入方式，以注解（以@开始）的方式注入bean --> <!-- 以注解方式注入bean --> <context:component-scanbase-package="com.phome"/> <!-- 以注解方式注入bean的属性 --> <context:annotation-config/> 4、添加struts配置文件(设置将Action交给spring管理) <!-- 与Spring集成的常量，让Spring接管Struts去创建Action对象 --> <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容器） <!-- 指定Spring配置文件的路径 --> <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value> </context-param> <!-- 实例化Spring容器 --> <listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> <!-- Struts2配置 --> <filter> <filter-name>struts2</filter-name> <filter-class> org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter </filter-class> </filter> <url-pattern>/*</url-pattern> 配置完成，在实际开发中。需要注意@service@repositycontroller上个注解。 面试复习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()方法主动通知虚拟机进 （编辑：李大同） 【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容! |