码迷，mamicode.com
首页 > 其他好文 > 详细

面试题1

时间：2018-06-11 02:08:54      阅读：169      评论：0      收藏：0      [点我收藏+]

标签：统计   springmvc   value   生效   service   bsp   静态方法   内存   hiberna   

面试题：

1.Oracle，MySQL数据库，面试官基本都会问，大家要重视，有的会问有没有了解过mangodb。

2.存储过程

  SQL语句需要先编译然后执行，而存储过程（Stored Procedure）是一组为了完成特定功能的SQL语句集，经编译后存储在数据库中，用户通过指定存储过程的名字并给定参数（如果该存储过程带有参数）来调用执行它。

存储过程是可编程的函数，在数据库中创建并保存，可以由SQL语句和控制结构组成。

         存储过程根据需要可能会有输入、输出、输入输出参数，共有三种参数类型,IN,OUT,INOUT

DELIMITER //

  CREATE PROCEDURE in_param(IN p_in int)

    BEGIN

    SELECT p_in;

    SET p_in=2;

    SELECT p_in;

    END;

    //

DELIMITER ;

#调用
SET @p_in=1;
CALL in_param(@p_in);

SELECT @p_in;

执行结果：

 

 

 

3.Mysql连接数据库方式

1、  利用DriverManager连接数据库

2、 public  static Connection getConnection() throws ClassNotFoundException{  

3、         String url="jdbc:mysql:///jdbc";//我连的数据库是MySQL中的jdbc数据库  

4、         String username="root";  

5、         String password="";//我的MySQL数据库的密码是空字符串  

6、         String driverClass="com.mysql.jdbc.Driver";  

7、         Connection ct=null;  

8、         Class.forName(driverClass);  

9、         try {  

10、                 ct=DriverManager.getConnection(url, username, password);  

11、             } catch (SQLException e) {   

12、                 e.printStackTrace();  

13、             }  

14、             return ct;  

15、         } 

2、利用io流读取文件的方式;

  1. // 读取类路径下的jdbc.propreties文件(配置文件)  
  2.         InputStream in = JDBCtool.class.getClassLoader().getResourceAsStream("jdbc.properties");  
  3.         // 以上为输入流  
  4.         Properties pt = new Properties();// 创建properties  
  5.         pt.load(in);// 取键值对（加载对应的输入流）  
  6.         driver = pt.getProperty("driver");  
  7.         jdbcurl = pt.getProperty("jdbcurl");  
  8.         user = pt.getProperty("user");  
  9.         password = pt.getProperty("password");  
  10. 10.         Connection ct = null;  

将diver、jdbcurl、user、password这些信息存储到类路径下的jdbc.propreties文件中

3、利用c3p0连接池连接数据库

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <c3p0-config>   
  3.     <named-config name="helloc3p0">   
  4. <!--     连接数据源的基本属性 -->  
  5.     <property name="user">root</property>   
  6.      <property name="password"></property>   
  7.      <property name="driverClass">com.mysql.jdbc.Driver</property>   
  8.      <property name="jdbcUrl">jdbc:mysql:///jdbc</property>   
  9.       

10. <!--     若数据库中连接数不足时，一次向数据库服务器申请多少个连接  -->  

  1. 11.     <property name="acquireIncrement">5</property>   

12. <!--         初始化数据库连接池时连接的数量 -->  

  1. 13.     <property name="initialPoolSize">5</property>   

14. <!--     数据库连接池中的最小的数据库连接数 -->  

  1. 15.     <property name="minPoolSize">5</property>   
  2. 16.     <!--     数据库连接池中的最大的数据库连接数 -->  
  3. 17.     <property name="maxPoolSize">10</property>   

18. <!--     c3p0数据库连接可以维护的statement的个数 -->  

  1. 19.     <property name="maxStatements">20</property>   

20. <!--     每个连接同时可以使用的statement对象的个数 -->  

  1. 21.     <property name="maxStatementsPerConnection">5</property>   
  2. 22.     </named-config>   

23. </c3p0-config>   

获取数据库连接的代码如下：

[java] view plain copy

  1. private static DataSource ds=null;  
  2.     //数据库连接池应只被初始化一次  
  3.     static{  
  4.         ds=new ComboPooledDataSource("helloc3p0");  
  5.     }  
  6.     //获取数据库连接  
  7.     public static  Connection getConnection() throws ClassNotFoundException, SQLException, IOException{  
  8.         return ds.getConnection();  
  9.           
  10. 10.       
  11. 11.     }  

4、利用mybatis-config.xml配置文件形式，利用MyBatis连接数据库

1配置文件:mybatis-config.xml

<configuration>   

    <environmentsdefault="environment"> 

        <environmentid="environment"> 

            <transactionManager type="JDBC"/> 

            <dataSourcetype="POOLED"> 

                <propertyname="driver" value="com.mysql.jdbc.Driver" /> 

                <propertyname="url"value="jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&amp;characterEncoding=utf8"/> 

               <property name="username" value="root" /> 

                <propertyname="password" value="root" /> 

            </dataSource> 

        </environment> 

    </environments> 

</configuration>

2.源代码：

public class JDBCUtilsDemo5{

       private static SqlSession session=null;

       public static SqlSession getSession(){

              try {

                     session= newSqlSessionFactoryBuilder().build(JDBCUtilsDemo5.class.getClassLoader().getResourceAsStream("mybatis-config.xml")).openSession();

关闭资源并在main方法中调用

4.左连接右链接内连接的区别

1、内联接（典型的联接运算，使用像 =  或 <> 之类的比较运算符）。包括相等联接和自然联接。     
内联接使用比较运算符根据每个表共有的列的值匹配两个表中的行。例如，检索 students和courses表中学生标识号相同的所有行。   
    
2、外联接。外联接可以是左向外联接、右向外联接或完整外部联接。     
在 FROM子句中指定外联接时，可以由下列几组关键字中的一组指定：     
1）LEFT  JOIN或LEFT OUTER JOIN     
左向外联接的结果集包括  LEFT OUTER子句中指定的左表的所有行，而不仅仅是联接列所匹配的行。如果左表的某行在右表中没有匹配行，则在相关联的结果集行中右表的所有选择列表列均为空值。       
2）RIGHT  JOIN 或 RIGHT  OUTER  JOIN     
右向外联接是左向外联接的反向联接。将返回右表的所有行。如果右表的某行在左表中没有匹配行，则将为左表返回空值。       
3）FULL  JOIN 或 FULL OUTER JOIN
完整外部联接返回左表和右表中的所有行。当某行在另一个表中没有匹配行时，则另一个表的选择列表列包含空值。如果表之间有匹配行，则整个结果集行包含基表的数据值。   

例子：   
-------------------------------------------------
  a表     id   name     b表     id   job   parent_id   
              1   张3                   1     23     1   
              2   李四                 2     34     2   
              3   王武                 3     34     4       
  a.id同parent_id   存在关系   
--------------------------------------------------    
 1） 内连接   
  select   a.*,b.*   from   a   inner   join   b     on   a.id=b.parent_id       
  结果是     
  1   张3                   1     23     1   
  2   李四                  2     34     2   

  2）左连接   
  select   a.*,b.*   from   a   left   join   b     on   a.id=b.parent_id       
  结果是     
  1   张3                   1     23     1   
  2   李四                  2     34     2   
  3   王武                  null   

 3） 右连接   
  select   a.*,b.*   from   a   right   join   b     on   a.id=b.parent_id       
  结果是     
  1   张3                   1     23     1   
  2   李四                  2     34     2   
  null                       3     34     4   

 4） 完全连接   
  select   a.*,b.*   from   a   full   join   b     on   a.id=b.parent_id   
  结果是     
  1   张3                  1     23     1   
  2   李四                 2     34     2   
  null               　　  3     34     4   
  3   王武                 null

5.对各个框架的理解，基本原理

传统的Java Web应用程序是采用JSP+Servlet+Javabean来实现的，这种模式实现了最基本的MVC分层，使的程序结构分为几层，有负责前台展示的JSP、负责流程逻辑控制的Servlet以及负责数据封装的Javabean。但是这种结构仍然存在问题：如JSP页面中需要使用<%%>符号嵌入很多的Java代码，造成页面结构混乱，Servlet和Javabean负责了大量的跳转和运算工作，耦合紧密，程序复用度低等等；

Struts框架，它是一个完美的MVC实现，它有一个中央控制类(一个Servlet)，针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输出显示，还有一个Form类负责传递Action和JSP中间的数据。JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。从此JSP页面中不需要出现一行<%%>包围的Java代码了。
  可是所有的运算逻辑都放在Struts的Action里将使得Action类复用度低和逻辑混乱，所以通常人们会把整个Web应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写；

Hibernate框架，它需要你创建一系列的持久化类，每个类的属性都可以简单的看做和一张数据库表的属性一一对应，当然也可以实现关系数据库的各种表件关联的对应。当我们需要相关操作是，不用再关注数据库表。我们不用再去一行行的查询数据库，只需要持久化类就可以完成增删改查的功能。使我们的软件开发真正面向对象，而不是面向混乱的代码。我的感受是，使用Hibernate比JDBC方式减少了80%的编程量。

显示层的Struts需要调用一个业务类，就需要new一个业务类出来，然后使用;业务层需要调用持久层的类，也需要new一个持久层类出来用。通过这种new的方式互相调用就是软件开发中最糟糕设计的体现；

Spring的作用就是完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。所以Spring框架最核心的就是所谓的依赖注射和控制反转。

现在的结构是，Struts负责显示层，Hibernate负责持久层，Spring负责中间的业务层，这个结构是目前国内最流行的Java Web应用程序架构了。另外，由于Spring使用的依赖注射以及AOP(面向方面编程)，所以它的这种内部模式非常优秀，以至于Spring自己也实现了一个使用依赖注射的MVC框架，叫做Spring MVC，同时为了很好的处理事物，Spring集成了Hibernate，使事物管理从Hibernate的持久层提升到了业务层，使用更加方便和强大。

SpringMVC原理：

Springmvc就是spring框架的一个模块,所以它可以和spring框架可以进行无缝整合,它是一个基于mvc设计思想的前端web框架,主要作用就是对前端请求进行处理。他的前端控制器是一个servlet.它的请求拦截是基于方法级别的.他的执行流程是

---》Spring的MVC框架主要由DispatcherServlet、处理器映射、处理器(控制器)、视图解析器、视图组成

1. 客户端请求提交到DispatcherServlet

2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller

3. DispatcherServlet将请求提交到Controller

4. Controller调用业务逻辑处理后，返回ModelAndView

5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图

6. 视图负责将结果显示到客户端

mvc指的就是Model（业务模型）、View（视图）、Controller（控制器）

----》Mybatis是一个优秀的ORM框架.应用在持久层. 它对jdbc的 操作数据库过程 进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、等jdbc繁杂的过程代码.一般使用mapper代理的方式开发.直接在xml里面写sql；

Mybatis的工作流程:

1、  mybatis配置

SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。

mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。

2、  通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂

3、  由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession(DefaultSqlSession)进行。

4、  mybatis底层自定义了Executor(BaseExecutor)执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。

5、  Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个Mapped Statement对象，sql的id即是Mapped statement的id。

6、  Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过 Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。

7、  Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过 Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

 

6.对Aop，ioc的理解

（1）aop:面向切面编程，将跟业务逻辑没有关系的代码提取出来，在调用目标方法之前或者之后执行。常用的场景，事务，日志，权限控制，异常处理等方面。

（2）ioc:创建对象的权利，交给spring容器创建。

（3）di：如果一个对象A需要使用另一个对象B才能实现某个功能，这时就可以说A对象依赖于B对象，而Spring容器在创建A对象时，会自动将A对象需要的B对象注入到A对象中，此过程就是依赖注入。

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

7.对Session共享的理解

 Java Servlet API引入session 机制来跟踪客户的状态，session指的是在一段时间内，单个客户和web服务器之间一连串的交互过程，在一个session中，一个客户可能会多次请求同一个网页，也可能请求多个不同服务器资源，例如：在一个邮件系统应用中，从一个客户登录到邮件系统，到写信，收信和发信等，到最后退出邮件系统，整个过程为一个session；再例如：大家在网上购物的时候，从购物到最后的付款，整个过程也是一个session 。

   session对像是jsp中的内置对象，可以直接使用；在Servlet中使用session时，必须先创建出该对象，Servlet中创建session的方法：

HttpSession session=request.getSession();或   HttpSession session=request.getSession(boolean value);

   在服务器上，通过session ID来区分每一个请求服务器的用户，用户只要一连接到服务器，服务器就会为之分配一个唯一的不会重复的session ID，session ID由服务器统一管理，人为不能控制。

          session中的主要方法：sesson.setAttribute(String key,Object value);//将对象存到session中   

session.getAttribute(String key);//获取session中存的Object对象 

session.invalidate();方法，强制session死亡

8.高并发的处理

  之前我将高并发的解决方法误认为是线程或者是队列可以解决，因为高并发的时候是有很多用户在访问，导致出现系统数据不正确、丢失数据现象，所以想到 的是用队列解决，其实队列解决的方式也可以处理，比如我们在竞拍商品、转发评论微博或者是秒杀商品等，同一时间访问量特别大，队列在此起到特别的作用，将 所有请求放入队列，以毫秒计时单位，有序的进行，从而不会出现数据丢失系统数据不正确的情况。

今天我经过查资料，高并发的解决方法有俩种，一种是使用缓存、另一种是使用生成静态页面；还有就是从最基础的地方优化我们写代码减少不必要的资源浪费：（

1.不要频繁的new对象,对于在整个应用中只需要存在一个实例的类使用单例模式.对于String的连接操作,使用StringBuffer或者StringBuilder.对于utility类型的类通过静态方法来访问。

2. 避免使用错误的方式,如Exception可以控制方法推出,但是Exception要保留stacktrace消耗性能,除非必要不要使用 instanceof做条件判断,尽量使用比的条件判断方式.使用JAVA中效率高的类,比如ArrayList比Vector性能好。)

首先缓存技术我一直没有使用过，我觉得应该是在用户请求时将数据保存在缓存中，下次请求时会检测缓存中是否有数据存在，防止多次请求服务器，导致服务器性能降低，严重导致服务器崩溃，这只是我自己的理解；

处理并发和同同步问题主要是通过锁机制。

   我们需要明白，锁机制有两个层面。

   一种是代码层次上的，如java中的同步锁，典型的就是同步关键字synchronized，这里我不在做过多的讲解，

   另外一种是数据库层次上的，比较典型的就是悲观锁和乐观锁。这里我们重点讲解的就是悲观锁（传统的物理锁）和乐观锁。

  悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自 外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。一个典型的倚赖数据库的悲观锁调用： 

       select * from account where name=”Erica” for update

       这条 sql 语句锁定了 account 表中所有符合检索条件（ name=”Erica” ）的记录。本次事务提交之前（事务提交时会释放事务过程中的锁），外界无法修改这些记录。

          乐观锁，大多是基于数据版本   Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来 实现。 读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提 交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据 版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。

        尽量使用缓存，包括用户缓存，信息缓存等，多花点内存来做缓存，可以大量减少与数据库的交互，提高性能。

用jprofiler等工具找出性能瓶颈，减少额外的开销。

优化数据库查询语句，减少直接使用hibernate等工具的直接生成语句（仅耗时较长的查询做优化）。

优化数据库结构，多做索引，提高查询效率。

统计的功能尽量做缓存，或按每天一统计或定时统计相关报表，避免需要时进行统计的功能。

能使用静态页面的地方尽量使用，减少容器的解析（尽量将动态内容生成静态html来显示）。

 

9.Redis缓存的存储方式

RDB方式

RDB方式的持久化是通过快照的方式完成的。当符合某种规则时，会将内存中的数据全量生成一份副本存储到硬盘上，这个过程称作”快照”，Redis会在以下几种情况下对数据进行快照：

根据配置规则进行自动快照；用户执行SAVE, BGSAVE命令；执行FLUSHALL命令；执行复制（replication）时。

AOF方式

在使用Redis存储非临时数据时，一般都需要打开AOF持久化来降低进程终止导致的数据丢失，AOF可以将Redis执行的每一条写命令追加到硬盘文件中，这已过程显然会降低Redis的性能，但是大部分情况下这个影响是可以接受的，另外，使用较快的硬盘能提高AOF的性能。

10.多线程相关知识

 

11.Sturts2和SpringMVC比较

注意:说出几点即可

1、springmvc入口是一个servlet前端控制器，struts2入口是一个filter过虑器。

2、struts2通过在action类中定义成员变量接收请求参数，struts2只能使用多例模式管理action。

springmvc通过在controller方法中定义形参接收请求参数，springmvc可以使用单例模式管理controller。

3、springmvc是基于方法开发的，注解开发中使用requestMapping将url和方法进行映射，如果根据url找到controller类的方法生成一个Handler处理器对象（只包括一个method）。

struts2是基于类开发，每个请求过来创建一个action实例，实例对象中有若干的方法。

开发中建议使用springmvc，springmvc方法更类似service业务方法。

4、Struts采用值栈存储请求和响应的数据，通过OGNL存取数据， springmvc通过参数绑定器是将request请求内容解析，并给方法形参赋值。

 

12.Mybatis和hibernate比较

1. 在移植性方面hibernate配置一下方言即可.而一般情况下mybatis则需要修改sql语句

2. hibernate是一个完全的ORM框架.完全的面向对象.更符合我们开发者的思维模式.mybatis需要我们手动写sql语句

3. hibernate的优化成本比较高.因为hibernate的sql语句是自动生成的,所以在优化方面一般的新手无从下手.而mybatis只要修改sql就可以了.更加容易上手

(如果对某一个框架非常了解.这里话锋可以转向具体的详细介绍某一个框架)

 

13.如何用aop实现事务管理

事物特性：

  1.原子性。

例如，转账，A账户减少，B账户增加。虽然是两条 DML语句，但是被当做是一个整体，一次事务。两条语句只能同时成功或者同时失败。

2.一致性。

账户A和B,要么都是转账前的状态，要么都是转账后的状态。(不能A账户的钱减少了但是B账户的钱没有增加)。

3.隔离性。

虽然在某个时间段很多人都在转账，但是每个人的转账都是在一个自己的事务中，彼此不会影响。

4.持久性。

事务提交成功后，数据修改永远生效。

（1）配置事务管理类

  1.  <!-- 定义事务管理器 -->    
  2. <bean id="transactionManager"    
  3.     class="org.springframework.jdbc.datasource.DataSourceTransactionManager">    
  4.     <property name="dataSource" ref="dataSource" />    
  5. </bean>    

（2）配置事务属性

<!-- 配置事务的属性 -->   

    <tx:advice id="TestAdvice" transaction-manager="transactionManager">   

        <!--配置事务传播性，隔离级别以及超时回滚等问题 -->   

        <tx:attributes>   

            <tx:method name="search*" propagation="REQUIRED" read-only="true" isolation="DEFAUT" TIMEOUT="-1" />   

            <tx:method name="del*" propagation="REQUIRED" />   

            <tx:method name="update*" propagation="REQUIRED" />   

            <tx:method name="add*" propagation="REQUIRED" />   

        </tx:attributes>   

</tx:advice> 

（3）配置事务的AOP切入点

  1. <aop:config>    
  2.         <!--配置事务切点 -->    
  3.         <aop:pointcut id="services"    
  4.             expression="execution(public* com.pb.service.*.*(..))" />    
  5.         <aop:advisor pointcut-ref="services" advice-ref="TestAdvice" />    
  6.     </aop:config>    

14.User表

  

写sql语句，查找表中名字相同的所有名字，还有数量

select u1.* from user u1

left join(select name,count(name)  c  from user

group by name

)  t2  on t1.name=t2.name

where c>1

order by c desc

 

15.i++有几个步骤，是不是原子性操作

 i++的操作分三步：

（1）栈中取出i

（2）i自增1

（3）将i存到栈

所以i++不是原子操作，上面的三个步骤中任何一个步骤同时操作，都可能导致i的值不正确自增.

 

16.在mapper.XML里面有大于号小于号的sql语句如何处理

  1、因为这个是xml格式的，所以不允许出现类似“>”这样的字符，但是都可以使用<![CDATA[ ]]>符号进行说明，将此类符号不进行解析 : 

mapper文件示例代码<![CDATA[ when min(starttime)<=‘12:00‘ and max(endtime)<=‘12:00‘ ]]>     

  2、用了转义字符把>和<替换掉SELECT * FROM test WHERE 1 = 1 AND start_date  &lt;= CURRENT_DATE AND end_date &gt;= CURRENT_DATE

XML转义字符

 &lt;

                     <

                     小于号

  &gt;

                     > 

                     大于号

&amp;

                     &

                     和

&apos;

                     ’

                     单引号

&quot;

                     "

                     双引号



 

 

 

 

 

17.、关于负责均衡的理解

18.数据报表用什么方式实现

19.Excel导出如何实现

20.怎样用jQuery添加样式

对css样式操作的方法：

1、.css("样式")：获得样式值，比如$("input").css("color")  获得input中字体的颜色

2、.css("样式","value"):为样式赋值，如$("input").css("color","red");

3、.addClass("样式类1,样式类2,样式类3"):可以添加多个定义好的样式类

 

21.多表连接，给我一个订单表一个商品表，通过订单表关联商品，要是商品表里面商品已经删除了，如何连接查询这个订单信息（有高人事后跟我说这是个坑，商品表不能关联订单表查询，不合法，主要是试试你到底是不是真的在公司做过项目）

22.Oracle分页怎么写

23.jQuery选择器有哪些

一、基本选择器

基本选择器是jQuery中最常用也是最简单的选择器，它通过元素的id、class和标签名等来查找DOM元素。

1、ID选择器 #id

描述：根据给定的id匹配一个元素， 返回单个元素（注：在网页中，id名称不能重复）

示例：$("#test") 选取 id 为 test 的元素

2、类选择器 .class

描述：根据给定的类名匹配元素，返回元素集合

示例：$(".test") 选取所有class为test的元素

3、元素选择器 element

描述：根据给定的元素名匹配元素，返回元素集合

示例：$("p") 选取所有的<p>元素

4、*

描述：匹配所有元素，返回元素集合

示例：$("*") 选取所有的元素

高级选择器:交集、并集、后代、子元素、属性。。。。。

 

24.Jsp页面怎样引入一个类

 <%@page import="com.ideal.dao.CommPayAppDao">

其中，类CommPayAppDao为代码src中包com/ideal/dao下面的dao类，这样你在jsp页面就可以像java类中写代码一样使用该类中的public方法。

 

25.Controller里面的数据通过什么方式返回到页面

 Spring MVC返回数据到页面有几种不同的方式，它们各自适用的情况也不同，下面简单总结一下。

对于每种方式都给出Controller中的相应方法。

首先还是页面user_add.jsp。它既是发出请求的页面，也是接收返回结果的页面：

  1. <%@ page language="java" import="java.util.*" contentType="text/html;charset=utf-8"%>  
  2. <html>  
  3.   <head>  
  4.     <title></title>  
  5.   </head>  
  6.   <body>  
  7.     <h1>添加用户信息4</h1>  
  8.     <form action="user/add4.do" method="post">  
  9.         <input type="submit" value="提交">  
  10.     </form>  
  11.     ${personId }  
  12.   </body>  
  13. </html>  

1、通过request对象：

  1. @RequestMapping("/add.do")  
  2. public String add(HttpServletRequest request){  
  3.     request.setAttribute("personId",12);  
  4.     return "user_add";  
  5. }  

2、通过ModelAndView对象：

  1. @RequestMapping("/add.do")  
  2. public ModelAndView add(){  
  3.     ModelAndView mav = new ModelAndView("user_add");  
  4.     mav.addObject("personId", 12);  
  5.     return mav;  
  6. }  

3、通过Model对象：

  1. @RequestMapping("/add.do")  
  2. public String add(Model model){  
  3.     model.addAttribute("personId", 12);  
  4.     return "user_add";  
  5. }  

4、通过Map对象：

  1. @RequestMapping("/add.do")  
  2. public String add(Map<String,Object> map){  
  3.     map.put("personId", 12);  
  4.     return "user_add";  
  5. }  

 

26.Mapper.XML里面要返回一个list集合怎么配，如果这个list集合里面是一个实体类对象又要怎么配

1、 直接写resultType="实体类"，这样返回列表的话就自动变成了List<实体类>

2、 <resultMap type="HashMap" id="testMap"> 

<result column="UA_INFO" property="key" /> 

<association property="value" resultMap="com.xxx.xxx.BaseResultMap"></association>  

</resultMap>

 

27.你们的项目数据库数据量最大的一张表数据量有多少

 

28.数据量大的表怎样提高查询效率

  1. 合理使用索引；
  2. 避免或简化排序；
  3. 消除对大型表行数据的顺序存取；
  4. 避免相关子查询；
  5. 避免困难的正规表达式；
  6. 使用临时表加速查询.

技术分享图片

技术分享图片

技术分享图片

技术分享图片

技术分享图片

面试题1

标签：统计   springmvc   value   生效   service   bsp   静态方法   内存   hiberna   

原文地址：https://www.cnblogs.com/yutianbao/p/9165117.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！