精华内容
下载资源
问答
  • java ssm面试题

    2019-01-08 10:43:40
    java ssm面试题,你值得拥有。
  • ssm面试题

    2020-11-27 09:55:30
    ssm面试题提问 一、什么是Mybatis (1)Mybatis是一个半ORM(对象关系映射)框架,它内部封装了JDBC,开发时只需要关注SQL语句本身,不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员...

    ssm面试题提问

    一、什么是Mybatis
    (1)Mybatis是一个半ORM(对象关系映射)框架,它内部封装了JDBC,开发时只需要关注SQL语句本身,不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql,可以严格控制sql执行性能,灵活度高。
    (2)MyBatis 可以使用 XML 或注解来配置和映射原生信息,将 POJO映射成数据库中的记录,避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
    (3)通过xml 文件或注解的方式将要执行的各种 statement 配置起来,并通过java对象和 statement中sql的动态参数进行映射生成最终执行的sql语句,最后由mybatis框架执行sql并将结果映射为java对象并返回。(从执行sql到返回result的过程)。

    二、Mybatis 的优缺点是什么?
    优点:
    (1)基于SQL语句编程,相当灵活,不会对应用程序或者数据库的现有设计造成任何影响,SQL写在XML里,解除sql与程序代码的耦合,便于统一管理;提供XML标签,支持编写动态SQL语句,并可重用。
    (2)与JDBC相比,减少了50%以上的代码量,消除了JDBC大量冗余的代码,不需要手动开关连接;
    (3)很好的与各种数据库兼容(因为MyBatis使用JDBC来连接数据库,所以只要JDBC支持的数据库MyBatis都支持)。
    (4)能够与Spring很好的集成;
    (5)提供映射标签,支持对象与数据库的ORM字段关系映射;提供对象关系映射标签,支持对象关系组件维护。
    缺点:
    (1)SQL语句的编写工作量较大,尤其当字段多、关联表多时,对开发人员编写SQL语句的功底有一定要求。
    (2)SQL语句依赖于数据库,导致数据库移植性差,不能随意更换数据库。

    三、MyBatis 与Hibernate 有哪些不同?
    (1)Mybatis和hibernate不同,它不完全是一个ORM框架,因为MyBatis需要程序员自己编写Sql语句。
    (2)Mybatis直接编写原生态sql,可以严格控制sql执行性能,灵活度高,非常适合对关系数据模型要求不高的软件开发,因为这类软件需求变化频繁,一但需求变化要求迅速输出成果。但是灵活的前提是mybatis无法做到数据库无关性,如果需要实现支持多种数据库的软件,则需要自定义多套sql映射文件,工作量大。
    (3)Hibernate对象/关系映射能力强,数据库无关性好,对于关系模型要求高的软件,如果用hibernate开发可以节省很多代码,提高效率。

    四、MyBatis 框架适用场合:
    MyBatis专注于SQL本身,是一个足够灵活的DAO层解决方案。
    对性能的要求很高,或者需求变化较多的项目,如互联网项目,MyBatis将是不错的选择。

    五、为什么说Mybatis是半自动ORM映射工具?它与全自动的区别在哪里?
    Hibernate属于全自动ORM映射工具,使用Hibernate查询关联对象或者关联集合对象时,可以根据对象关系模型直接获取,所以它是全自动的。而Mybatis在查询关联对象或关联集合对象时,需要手动编写sql来完成,所以,称之为半自动ORM映射工具。

    六、当实体类中的属性和表中的字段不一致时怎么办?
    第1种: 通过在查询的sql语句中定义字段名的别名,让字段名的别名和实体类的属性名一致。
    <select id=”selectorder”parametertype=”int”resultetype=”me.gacl.domain.order”>
    select order_id id, order_no orderno ,order_price price form orders where order_id=#{id};

    第2种: 通过来映射字段名和实体类属性名的一一对应的关系。

    select * from orders where order_id=#{id}

    	 <resultMap type=”me.gacl.domain.order” id=”orderresultmap”>
        	<!–用id属性来映射主键字段–>
       		 <id property=”id” column=”order_id”>
    
       		 <!–用result属性来映射非主键字段,property为实体类属性名,column为数据表中的属性–>
       	 	<result property = “orderno” column =”order_no”/>
        	<result property=”price” column=”order_price” />
    	</reslutMap>
    

    七、Mybatis 是如何分页的?分页插件的原理是什么?
    Mybatis使用RowBounds对象进行分页,它是针对ResultSet结果集执行的内存分页,而非物理分页。可以在sql内直接书写带有物理分页的参数来完成物理分页功能,也可以使用分页插件来完成物理分页。
    分页插件的基本原理是使用Mybatis提供的插件接口,实现自定义插件,在插件的拦截方法内拦截待执行的sql,然后重写sql,根据dialect方言,添加对应的物理分页语句和物理分页参数。

    八、Mybatis 是如何将 sql 结果封装为目标对象并返回的?都有哪些映射形式?
    第一种是使用标签,逐一定义数据库列名和对象属性名之间的映射关系。
    第二种是使用sql列的别名功能,将列的别名书写为对象属性名。
    有了列名与属性名的映射关系后,Mybatis通过反射创建对象,同时使用反射给对象的属性逐一赋值并返回,那些找不到映射关系的属性,是无法完成赋值的。

    九、Mybatis 实现一对一有几种方式?具体怎么操作
    有联合查询和嵌套查询,联合查询是几个表联合查询,只查询一次, 通过在resultMap里面配置association节点配置一对一的类就可以完成;
    嵌套查询是先查一个表,根据这个表里面的结果的 外键id,去再另外一个表里面查询数据,也是通过association配置,但另外一个表的查询通过select属性配置。

    十、MyBatis实现一对多有几种方式,怎么操作的?
    有联合查询和嵌套查询。联合查询是几个表联合查询,只查询一次,通过在resultMap里面的collection节点配置一对多的类就可以完成;嵌套查询是先查一个表,根据这个表里面的 结果的外键id,去再另外一个表里面查询数据,也是通过配置collection,但另外一个表的查询通过select节点配置。

    十一、Mybatis 是否支持延迟加载?如果支持,它的实现原理是什么?
    Mybatis仅支持association关联对象和collection关联集合对象的延迟加载,association指的就是一对一,collection指的就是一对多查询。在Mybatis配置文件中,可以配置是否启用延迟加载lazyLoadingEnabled=true|false。
    它的原理是,使用CGLIB创建目标对象的代理对象,当调用目标方法时,进入拦截器方法,比如调用a.getB().getName(),拦截器invoke()方法发现a.getB()是null值,那么就会单独发送事先保存好的查询关联B对象的sql,把B查询上来,然后调用a.setB(b),于是a的对象b属性就有值了,接着完成a.getB().getName()方法的调用。这就是延迟加载的基本原理。
    当然了,不光是Mybatis,几乎所有的包括Hibernate,支持延迟加载的原理都是一样的。

    **十二、#{}和KaTeX parse error: Expected 'EOF', got '#' at position 17: …} 的区别是什么** (1)#̲{}是预编译处理,{}是字符串替换。
    (2)Mybatis在处理#{}时,会将sql中的#{}替换为?号,调用PreparedStatement的set方法来赋值;
    (3) Mybatis在处理 时 , 就 是 把 {}时,就是把 {}替换成变量的值。
    (4)使用#{}可以有效的防止SQL注入,提高系统安全性。

    十三、通常一个Xml 映射文件,都会写一个Dao 接口与之对应,请问,这个Dao 接口的工作原理是什么?Dao 接口里的方法, 参数不同时,方法能重载吗?
    Dao接口即Mapper接口。接口的全限名,就是映射文件中的namespace的值;接口的方法名,就是映射文件中Mapper的Statement的id值;接口方法内的参数,就是传递给sql的参数。
    Mapper接口是没有实现类的,当调用接口方法时,接口全限名+方法名拼接字符串作为key值,可唯一定位一个MapperStatement。在Mybatis中,每一个、、、标签,都会被解析为一个MapperStatement对象。
    举例:com.mybatis3.mappers.StudentDao.findStudentById,可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面 id 为 findStudentById 的 MapperStatement。
    Mapper接口里的方法,是不能重载的,因为是使用 全限名+方法名 的保存和寻找策略。Mapper 接口的工作原理是JDK动态代理,Mybatis运行时会使用JDK动态代理为Mapper接口生成代理对象proxy,代理对象会拦截接口方法,转而执行MapperStatement所代表的sql,然后将sql执行结果返回。

    十四、如何获取自动生成的(主)键值?
    insert 方法总是返回一个int值 ,这个值代表的是插入的行数。
    如果采用自增长策略,自动生成的键值在 insert 方法执行完后可以被设置到传入的参数对象中。
    示例:

    insert into names (name) values (#{name})

    	name name = new name();
    	name.setname(“fred”);
    
    	 int rows = mapper.insertname(name);
    	 // 完成后,id已经被设置到对象中
    	 system.out.println(“rows inserted = ” + rows);
    	system.out.println(“generated key value = ” + name.getid());
    

    十五、在 mapper 中如何传递多个参数?
    (1)第一种:
    //DAO层的函数
    Public UserselectUser(String name,String area);
    //对应的xml,#{0}代表接收的是dao层中的第一个参数,#{1}代表dao层中第二参数,更多参数一致往后加即可。

    <select id="selectUser"resultMap="BaseResultMap">  
        select *  fromuser_user_t   whereuser_name = #{0} anduser_area=#{1}  
    </select>  
    

    (2)第二种: 使用 @param 注解:

    public interface usermapper {
       user selectuser(@param(“username”) string username,@param(“hashedpassword”) string hashedpassword);
    }
    

    然后,就可以在xml像下面这样使用(推荐封装为一个map,作为单个参数传递给mapper):

    <select id=”selectuser” resulttype=”user”>
             select id, username, hashedpassword
             from some_table
             where username = #{username}
             and hashedpassword = #{hashedpassword}
    </select>
    

    (3)第三种:多个参数封装成map
    try{
    //映射文件的命名空间.SQL片段的ID,就可以调用对应的映射文件中的SQL
    //由于我们的参数超过了两个,而方法中只有一个Object参数收集,因此我们使用Map集合来装载我们的参数

    Map<String, Object> map = new HashMap();
         map.put("start", start);
         map.put("end", end);
         return sqlSession.selectList("StudentID.pagination", map);
     }catch(Exception e){
         e.printStackTrace();
         sqlSession.rollback();
        throw e; }
    finally{
     MybatisUtil.closeSqlSession();
     }
    

    十六、Mybatis 动态sql 有什么用?执行原理?有哪些动态sql?
    Mybatis动态sql可以在Xml映射文件内,以标签的形式编写动态sql,执行原理是根据表达式的值 完成逻辑判断并动态拼接sql的功能。
    Mybatis提供了9种动态sql标签:trim | where | set | foreach | if | choose | when | otherwise | bind。

    十七、使用 MyBatis 的mapper 接口调用时有哪些要求?
    ① Mapper接口方法名和mapper.xml中定义的每个sql的id相同;
    ② Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同;
    ③ Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同;
    ④ Mapper.xml文件中的namespace即是mapper接口的类路径。

    十八、什么情况下用注解绑定,什么情况下用xml绑定?
    当Sql语句比较简单时候,用注解绑定,
    当SQL语句比较复杂时候,用xml绑定,一般用xml绑定的比较多

    十九、模糊查询like语句该怎么写
    第1种:在Java代码中添加sql通配符。
    string wildcardname = “%smi%”;
    list names = mapper.selectlike(wildcardname);

    	<select id=”selectlike”>
    		 select * from foo where bar like #{value}
    	</select>
    第2种:在sql语句中拼接通配符,会引起sql注入
    	string wildcardname = “smi”;
    	 list<name> names = mapper.selectlike(wildcardname);
    
    	<select id=”selectlike”>
         	select * from foo where bar like "%"${value}"%"
    	</select>
    

    二十、Mybatis的Xml映射文件中,不同的Xml映射文件,id是否可以重 复?
    不同的Xml映射文件,如果配置了namespace,那么id可以重复;如果没有配置namespace,那么id不能重复;
    原因就是namespace+id是作为Map<String, MapperStatement>的key使用的,如果没有namespace,就剩下id,那么,id重复会导致数据互相覆盖。有了namespace,自然id就可以重复,namespace不同,namespace+id自然也就不同。
    但是,在以前的Mybatis版本的namespace是可选的,不过新版本的namespace已经是必须的了。

    二十一、Mybatis是否可以映射Enum枚举类?
    Mybatis 可以映射枚举类。
    不单可以映射枚举类,Mybatis 可以映射任何对象到表的一列上。映射方式为自定义一个 TypeHandler ,实现 TypeHandler 的 ​setParameter()​ 和 ​getResult()​ 接口方法。
    TypeHandler 有两个作用,一是完成从 javaType 至 jdbcType 的转换,二是完成 jdbcType 至 javaType 的转换,体现为 ​setParameter() ​和 ​getResult()​ 两个方法,分别代表设置 sql 问号占位符参数和获取列查询结果。

    二十二、列举mybatis中涉及到的设计模式
    1)、Builder模式:例如SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder、CacheBuilder
    2)、工厂模式:例如SqlSessionFactory、ObjectFactory、MapperProxyFactory
    3)、单例模式:例如LogFactory、ErrorContext
    4)、代理模式:mybatis实现的核心,比如MapperProxy、ConnectionLogger、用的jdk的动态代理,还有executor.loader包使用了cglib或者javassist达到延迟加载的效果
    5)、组合模式:例如SqlNode和各个子类ChooseSqlNode等
    6)、模板方法模式:例如BaseExecutor和SimpleExecutor,还有BaseTypeHandler和所有的子类例如IntegerTypeHandler
    7)、适配器模式:例如Log的Mybatis接口和它对jdbc、log4j等各种日志框架的适配实现
    8)、装饰者模式:例如Cache包中的cache.decorators子包中的各个装饰者的实现
    9)、迭代器模式:例如迭代器模式PropertyTokenizer

    二十三、resultType resultMap 的区别?
    MyBatis中在查询进行select映射的时候,返回类型可以用resultType,也可以用resultMap,resultType是直接表示返回类型的,而resultMap则是对外部ResultMap的引用,但是resultType跟resultMap不能同时存在。
    在MyBatis进行查询映射时,其实查询出来的每一个属性都是放在一个对应的Map里面的,其中键是属性名,值则是其对应的值。
    ①当提供的返回类型属性是resultType时,MyBatis会将Map里面的键值对取出赋给resultType所指定的对象对应的属性。所以其实MyBatis的每一个查询映射的返回类型都是ResultMap,只是当提供的返回类型属性是resultType的时候,MyBatis对自动的给把对应的值赋给resultType所指定对象的属性。
    ②当提供的返回类型是resultMap时,因为Map不能很好表示领域模型,就需要自己再进一步的把它转化为对应的对象,这常常在复杂查询中很有作用。

    二十四、Mybatis 的一级缓存、二级缓存
    (1)一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存,其存储作用域为 Session,当 Session flush 或 close 之后,该 Session 中的所有 Cache 就将清空,默认打开一级缓存。
    (2)二级缓存与一级缓存其机制相同,默认也是采用 PerpetualCache,HashMap 存储,不同在于其存储作用域为 Mapper(Namespace),并且可自定义存储源,如 Ehcache。默认不打开二级缓存,要开启二级缓存,使用二级缓存属性类需要实现Serializable序列化接口(可用来保存对象的状态),可在它的映射文件中配置 ;
    (3)对于缓存数据更新机制,当某一个作用域(一级缓存 Session/二级缓存Namespaces)的进行了C/U/D 操作后,默认该作用域下所有 select 中的缓存将被 clear 掉并重新更新,如果开启了二级缓存,则只根据配置判断是否刷新。

    spring

    一、Spring 的优点?
    (1)spring属于低侵入式设计,代码的污染极低;
    (2)spring的DI机制将对象之间的依赖关系交由框架处理,减低组件的耦合性;
    (3)Spring提供了AOP技术,支持将一些通用任务,如安全、事务、日志、权限等进行集中式管理,从而提供更好的复用。
    (4)spring对于主流的应用框架提供了集成支持。

    二、列举一些重要的Spring模块?
    Spring的模块主要有Core、Aspects、AOP、JDBC、JMS、ORM、Web及Test等,Spring模块及其作用如下所示:
    Spring Core:基础模块,Spring很多功能都需要依赖于该类库,主要提供IOC依赖注入功能;
    Spring Aspects:Aspects模块为AspectJ的集成提供支持;
    Spring AOP:AOP提供面向方面的编程实现;
    Spring JDBC:JDBC模块用于Java数据库连接;
    Spring JMS:JMS用于Java消息服务;
    Spring ORM:ORM用于支持Hibernate等ORM工具;
    Spring Web:Web模块,顾名思义为创建Web应用程序提供支持;
    Spring Test:Test模块提供对JUnit和TestNG的测试支持。

    三、谈谈自己对于 Spring IoC 和 AOP 的理解
    IoC:
    (1)IOC就是控制反转,是指创建对象的控制权的转移,以前创建对象的主动权和时机是由自己把控的,而现在这种权力转移到Spring容器中,并由容器根据配置文件去 创建实例和管理各个实例之间的依赖关系,对象与对象之间松散耦合,也利于功能的复用。DI依赖注入,和控制反转是同一个概念的不同角度的描述,即 应用程序在运行时 依赖IoC容器来动态注入对象需要的外部资源。
    (2)最直观的表达就是,IOC让对象的创建不用去new了,可以由spring自动生产,使用java的反射机制,根据配置文件在运行时动态的去创建对象以及管理对象,并调用 对象的方法的。
    (3)Spring的IOC有三种注入方式 :构造器注入、setter方法注入、根据注解注入。
    IoC让相互协作的组件保持松散的耦合,而AOP编程允许你把遍布于应用各层的功能分离出来形成可重用的功能组件。
    AOP:
    OOP面向对象,允许开发者定义纵向的关系,但并适用于定义横向的关系,导致了大量代码的重复,而不利于各个模块的重用。
    AOP,一般称为面向切面,作为面向对象的一种补充,用于将那些与业务无关,但却对多个对象产生影响的公共行为和逻辑,抽取并封装为一个可重用的模块,这个模 块被命名为“切面”(Aspect),减少系统中的重复代码,降低了模块间的耦合度,同时提高了系统的可维护性。可用于权限认证、日志、事务处理。
    AOP实现的关键在于 代理模式,AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ;动态代理则以Spring AOP为代表。
    (1)AspectJ是静态代理的增强,所谓静态代理,就是AOP框架会在编译阶段生成AOP代理类,因此也称为编译时增强,他会在编译阶段将AspectJ(切面)织入到Java字节 码中,运行的时候就是增强之后的AOP对象。
    (2)Spring AOP使用的动态代理,所谓的动态代理就是说AOP框架不会去修改字节码,而是每次运行时在内存中临时为方法生成一个AOP对象,这个AOP对象包含了目 标对象的全部方法,并且在特定的切点做了增强处理,并回调原对象的方法。
    Spring AOP中的动态代理主要有两种方式,JDK动态代理和CGLIB动态代理:
    ①JDK动态代理只提供接口的代理,不支持类的代理。核心InvocationHandler接口和Proxy类,InvocationHandler 通过invoke()方法反射来调用目标类中的代码,动态地 将横切逻辑和业务编织在一起;接着,Proxy利用 InvocationHandler动态创建一个符合某一接口的的实例, 生成目标类的代理对象。
    ②如果代理类没有实现 InvocationHandler 接口,那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB(Code Generation Library),是一个代码生成的类库, 可以在运行时动态的生成指定类的一个子类对象,并覆盖其中特定方法并添加增强代码,从而实现AOP。CGLIB是通过继承的方式做的动态代理,因此如果某个类被标记为 final,那么它是无法使用CGLIB做动态代理的。
    (3)静态代理与动态代理区别在于生成AOP代理对象的时机不同,相对来说AspectJ的静态代理方式具有更好的性能,但是AspectJ需要特定的编译器进行处理,而Spring AOP则无需特定的编译器处理。
    InvocationHandler 的 invoke(Object proxy,Method method,Object[] args):proxy是最终生成的代理实例; method 是被代理目标实例的某个具体方法; args 是被代理目 标实例某个方法的具体入参, 在方法反射调用时使用。

    四、Spring 中的 bean 的作用域有哪些?
    Spring容器中的bean可以分为5个范围:
    (1)singleton:默认,每个容器中只有一个bean的实例,单例的模式由BeanFactory自身来维护。
    (2)prototype:为每一个bean请求提供一个实例。
    (3)request:为每一个网络请求创建一个实例,在请求完成以后,bean会失效并被垃圾回收器回收。
    (4)session:与request范围类似,确保每个session中有一个bean的实例,在session过期后,bean会随之失效。
    (5)global-session:全局作用域,global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时,它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话,那么这全局变量需要存储在global-session中。全局作用域与Servlet中的session作用域效果相同。

    五、Spring中的Bean是线程安全的嘛?
    Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。但实际上,大部分的Spring bean并没有可变的状态(比如Serview类和DAO类),所以在某种程度上说Spring的单例bean是线程安全的。如果你的bean有多种状态的话(比如 View Model 对象),就需要自行保证线程安全。最浅显的解决办法就是将多态bean的作用域由“singleton”变更为“prototype”。

    六、Spring AOP 和 AspectJ AOP 有什么区别?
    Spring AOP
    1、基于动态代理来实现,默认如果使用接口的,用JDK提供的动态代理实现,如果是方法则使用CGLIB实现
    2、Spring AOP需要依赖IOC容器来管理,并且只能作用于Spring容器,使用纯Java代码实现
    3、在性能上,由于Spring AOP是基于动态代理来实现的,在容器启动时需要生成代理实例,在方法调用上也会增加栈的深度,使得Spring AOP的性能不如AspectJ的那么好
    AspectJ AOP
    AspectJ来自于Eclipse基金会
    AspectJ属于静态织入,通过修改代码来实现,有如下几个织入的时机:
    ​ 1、编译期织入(Compile-time weaving): 如类 A 使用 AspectJ 添加了一个属性,类 B 引用了它,这个场景就需要编译期的时候就进行织入,否则没法编译类 B。
    ​ 2、编译后织入(Post-compile weaving): 也就是已经生成了 .class 文件,或已经打成 jar 包了,这种情况我们需要增强处理的话,就要用到编译后织入。
    ​ 3、类加载后织入(Load-time weaving): 指的是在加载类的时候进行织入,要实现这个时期的织入,有几种常见的方法。
    1、自定义类加载器来干这个,这个应该是最容易想到的办法,在被织入类加载到 JVM 前去对它进行加载,这样就可以在加载的时候定义行为了。
    2、在 JVM 启动的时候指定 AspectJ 提供的 agent:-javaagent:xxx/xxx/aspectjweaver.jar。
    AspectJ可以做Spring AOP干不了的事情,它是AOP编程的完全解决方案,Spring AOP则致力于解决企业级开发中最普遍的AOP(方法织入)。而不是成为像AspectJ 一样的AOP方案
    因为AspectJ在实际运行之前就完成了织入,所以说它生成的类是没有额外运行时开销的
    下表总结了 Spring AOP 和 AspectJ 之间的关键区别:

    Spring AOPAspectJ AOP
    在纯Java中实现使用Java编程语言的拓展实现
    不需要单独的编译过程除非设置LTW,否则需要AspectJ编译器(ajc)
    只能使用运行时织入运行时织入不可用,支持编译时、编译后和加载时织入
    功能不强-仅支持方法级编织更强大-可以编织字段、方法、构造函数、静态初始值设定项、最终类/方法等
    只能在由Spring容器管理的bean上实现可以在所有域对象上实现
    仅支持方法执行切入点支持所有切入点
    代理是由目标创建的,并且切面应用在这些代理上在执行应用程序之前(在运行时)前,各方面直接在代码中进行织入
    比AspectJ慢多了更好的性能
    容易学习和应用相对于Spring AOP来说更复杂

    七、@Component 和 @Bean 的区别是什么?
    @Component注解表明一个类会作为组件类,并告知Spring要为这个类创建bean。
    @Bean注解告诉Spring这个方法将会返回一个对象,这个对象要注册为Spring应用上下文中的bean。通常方法体中包含了最终产生bean实例的逻辑。
    两者的目的是一样的,都是注册bean到Spring容器中。区别在于:
    @Component(@Controller、@Service、@Repository)通常是通过类路径扫描来自动侦测以及自动装配到Spring容器中。
    而@Bean注解通常是我们在标有该注解的方法中定义产生这个bean的逻辑。
    @Component 作用于类,@Bean作用于方法。
    @Component和@Bean都是用来注册Bean并装配到Spring容器中,但是Bean比Component的自定义性更强。可以实现一些Component实现不了的自定义加载类。
    八、Spring 管理事务的方式有几种?
    实现方式共有两种:编码方式;声明式事务管理方式。
    1、基于AOP技术实现的声明式事务管理,实质就是:在方法执行前后进行拦截,然后在目标方法开始之前创建并加入事务,执行完目标方法后根据执行情况提交或回滚事务。
    2、声明式事务管理又有两种方式:基于XML配置文件的方式;另一个是在业务方法上进行@Transactional注解,将事务规则应用到业务逻辑中。
    九、将一个类声明为Spring的 bean 的注解有哪些?
    我们一般使用 @Autowired 注解自动装配 bean,要想把类标识成可用于 @Autowired注解自动装配的 bean 的类,采用以下注解可实现:
    1)、@Component :通用的注解,可标注任意类为 Spring 组件。如果一个Bean不知道属于哪个层,可以使用
    2)、@Repository : 对应持久层即 Dao 层,主要用于数据库相关操作。
    3)、@Service :对应服务层,主要涉及一些复杂的逻辑,需要用到 Dao层。
    4)、@Controller : 对应 Spring MVC控制层,主要用户接受用户请求并调用 Service 层返回数据给前端页面。
    十、Spring 中的 bean 生命周期?
    首先说一下Servlet的生命周期:实例化,初始init,接收请求service,销毁destroy;
    Spring上下文中的Bean生命周期也类似,如下:
    (1)实例化Bean:
    对于BeanFactory容器,当客户向容器请求一个尚未初始化的bean时,或初始化bean的时候需要注入另一个尚未初始化的依赖时,容器就会调用createBean进行实例化。对于ApplicationContext容器,当容器启动结束后,通过获取BeanDefinition对象中的信息,实例化所有的bean。
    (2)设置对象属性(依赖注入):
    实例化后的对象被封装在BeanWrapper对象中,紧接着,Spring根据BeanDefinition中的信息 以及 通过BeanWrapper提供的设置属性的接口完成依赖注入。
    (3)处理Aware接口:
    接着,Spring会检测该对象是否实现了xxxAware接口,并将相关的xxxAware实例注入给Bean:
    ①如果这个Bean已经实现了BeanNameAware接口,会调用它实现的setBeanName(String beanId)方法,此处传递的就是Spring配置文件中Bean的id值;
    ②如果这个Bean已经实现了BeanFactoryAware接口,会调用它实现的setBeanFactory()方法,传递的是Spring工厂自身。
    ③如果这个Bean已经实现了ApplicationContextAware接口,会调用setApplicationContext(ApplicationContext)方法,传入Spring上下文;
    (4)BeanPostProcessor:
    如果想对Bean进行一些自定义的处理,那么可以让Bean实现了BeanPostProcessor接口,那将会调用postProcessBeforeInitialization(Object obj, String s)方法。
    (5)InitializingBean 与 init-method:
    如果Bean在Spring配置文件中配置了 init-method 属性,则会自动调用其配置的初始化方法。
    (6)如果这个Bean实现了BeanPostProcessor接口,将会调用postProcessAfterInitialization(Object obj, String s)方法;由于这个方法是在Bean初始化结束时调用的,所以可以被应用于内存或缓存技术;
    以上几个步骤完成后,Bean就已经被正确创建了,之后就可以使用这个Bean了。
    (7)DisposableBean:
    当Bean不再需要时,会经过清理阶段,如果Bean实现了DisposableBean这个接口,会调用其实现的destroy()方法;
    (8)destroy-method:
    最后,如果这个Bean的Spring配置中配置了destroy-method属性,会自动调用其配置的销毁方法。

    十一、Spring 事务中的隔离级别有哪几种?
    ① ISOLATION_DEFAULT:这是个 PlatfromTransactionManager 默认的隔离级别,使用数据库默认的事务隔离级别。
    ② ISOLATION_READ_UNCOMMITTED:读未提交,允许另外一个事务可以看到这个事务未提交的数据。
    ③ ISOLATION_READ_COMMITTED:读已提交,保证一个事务修改的数据提交后才能被另一事务读取,而且能看到该事务对已有记录的更新。
    ④ ISOLATION_REPEATABLE_READ:可重复读,保证一个事务修改的数据提交后才能被另一事务读取,但是不能看到该事务对已有记录的更新。
    ⑤ ISOLATION_SERIALIZABLE:一个事务在执行的过程中完全看不到其他事务对数据库所做的更新。

    十二、Spring 事务中哪几种事务传播行为?
    ① PROPAGATION_REQUIRED:如果当前没有事务,就创建一个新事务,如果当前存在事务,就加入该事务,该设置是最常用的设置。
    ② PROPAGATION_SUPPORTS:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就以非事务执行。‘
    ③ PROPAGATION_MANDATORY:支持当前事务,如果当前存在事务,就加入该事务,如果当前不存在事务,就抛出异常。
    ④ PROPAGATION_REQUIRES_NEW:创建新事务,无论当前存不存在事务,都创建新事务。
    ⑤ PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。
    ⑥ PROPAGATION_NEVER:以非事务方式执行,如果当前存在事务,则抛出异常。
    ⑦ PROPAGATION_NESTED:如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则按REQUIRED属性执行。

    十三、BeanFactory和ApplicationContext有什么区别?
    BeanFactory和ApplicationContext是Spring的两大核心接口,都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。
    (1)BeanFactory:是Spring里面最底层的接口,包含了各种Bean的定义,读取bean配置文档,管理bean的加载、实例化,控制bean的生命周期,维护bean之间的依赖关系。ApplicationContext接口作为BeanFactory的派生,除了提供BeanFactory所具有的功能外,还提供了更完整的框架功能:
    ①继承MessageSource,因此支持国际化。
    ②统一的资源文件访问方式。
    ③提供在监听器中注册bean的事件。
    ④同时加载多个配置文件。
    ⑤载入多个(有继承关系)上下文 ,使得每一个上下文都专注于一个特定的层次,比如应用的web层。
    (2)①BeanFactroy采用的是延迟加载形式来注入Bean的,即只有在使用到某个Bean时(调用getBean()),才对该Bean进行加载实例化。这样,我们就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入,BeanFacotry加载后,直至第一次使用调用getBean方法才会抛出异常。
    ②ApplicationContext,它是在容器启动时,一次性创建了所有的Bean。这样,在容器启动时,我们就可以发现Spring中存在的配置错误,这样有利于检查所依赖属性是否注入。 ApplicationContext启动后预载入所有的单实例Bean,通过预载入单实例bean ,确保当你需要的时候,你就不用等待,因为它们已经创建好了。
    ③相对于基本的BeanFactory,ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时,程序启动较慢。
    (3)BeanFactory通常以编程的方式被创建,ApplicationContext还能以声明的方式创建,如使用ContextLoader。
    (4)BeanFactory和ApplicationContext都支持BeanPostProcessor、BeanFactoryPostProcessor的使用,但两者之间的区别是:BeanFactory需要手动注册,而ApplicationContext则是自动注册。

    十四、在applicationgContext.xml文件中定义了一个bean,id为authService,通过ApplicationContext实例对象的getBean方法获取到这个bean,这个背后的实现原理是什么?
    Spring容器启动的时候会解析applicationgContext.xml,将xml中定义的bean(如authService)解析成Spring内部的BeanDefinition,并以beanName(如authService)为key,BeanDefinition(如authService相应的BeanDefinition)为value存储到DefaultListableBeanFactory中的beanDefinitionMap属性中(其实它就是一个ConcurrentHashMap类型的属性),同时将beanName存入beanDefinitionNames中(List类型),然后遍历beanDefinitionNames中的beanName,进行bean的实例化并填充属性,在实例化的过程中,如果有依赖没有被实例化将先实例化其依赖,然后实例化本身,实例化完成后将实例存入单例bean的缓存中,当调用getBean方法时,到单例bean的缓存中查找,如果找到并经过转换后返回这个实例(如AuthService的实例),之后就可以直接使用了。

    十五、如何理解BeanFactory和FactoryBean?
    BeanFactory是接口,提供了IOC容器最基本的形式,给具体的IOC容器的实现提供了规范
    FactoryBean也是接口,为IOC容器中Bean的实现提供了更加灵活的方式,FactoryBean在IOC容器的基础上给Bean的实现加上了一个简单工厂模式和装饰模式, 我们可以在getObject()方法中灵活配置。其实在Spring源码中有很多FactoryBean的实现类.

    区别:BeanFactory是个Factory,也就是IOC容器或对象工厂,FactoryBean是个Bean。在Spring中,所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言,这个Bean不是简单的Bean,而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似

    十六、@autowire和@resource区别
    (1)提供方:@Autowired是由org.springframework.beans.factory.annotation.Autowired提供,换句话说就是由Spring提供;@Resource是由javax.annotation.Resource提供,即J2EE提供,需要JDK1.6及以上。
    (2)注入方式:@Autowired只按照byType 注入;@Resource默认按byName自动注入,也提供按照byType 注入;
    (3)属性:@Autowired按类型装配依赖对象,默认情况下它要求依赖对象必须存在,如果允许null值,可以设置它required属性为false。如果我们想使用按名称装配,可以结合@Qualifier注解一起使用。@Resource有两个中重要的属性:name和type。name属性指定byName,如果没有指定name属性,当注解标注在字段上,即默认取字段的名称作为bean名称寻找依赖对象,当注解标注在属性的setter方法上,即默认取属性名作为bean名称寻找依赖对象。需要注意的是,@Resource如果没有指定name属性,并且按照默认的名称仍然找不到依赖对象时, @Resource注解会回退到按类型装配。但一旦指定了name属性,就只能按名称装配了。

    十七、在bean实例化的过程中,Spring是如何解决循环依赖的?
    Spring主要的思路就是依据三级缓存,在实例化A时调用doGetBean,发现A依赖的B的实例,此时调用doGetBean去实例B,实例化的B的时候发现又依赖A,如果不解决这个循环依赖的话此时的doGetBean将会无限循环下去,导致内存溢出,程序奔溃。spring引用了一个早期对象,并且把这个"早期引用"并将其注入到容器中,让B先完成实例化,此时A就获取B的引用,完成实例化。

    十八、讲讲Spring加载流程。
    1)、执行 Web.XML 中的 ContextLoaderListener 监听器
    2)、初始化 COntextLoaderListener 中的 ContextInitialized 方法
    3)、ContextInitialized 方法中调用父类 ( ContextLoader ) 的 initWebAppcalicationContext 的方法
    4)、initWebAppcalitionContext 方法中执行了三个任务
    1)、创建 WebApplicationContext 容器
    2)、加载 Context-Param 中配置的 Spring 配置文件
    3)、初始化配置文件中及创建配置文件中的 bean
    5)、Web 容器停止时候会执行 ContextLoaderLoaderListener 的 ContextDesroyed 方法销毁 Context 容器

    十九、Spring AOP的实现原理。
    1)、AOP 的全称是 Aspect Orient Programming ,即面向切面编程。是对 OOP (Object Orient Programming) 的一种补充,专门用于处理一些具有横切性质的服务。常常用 于日志输出、、安全控制等。
    2)、AOP(面向切面编程思想)主要是的实现技术有 Spring AOP 和 AspectJ。
    1)、AspectJ 的底层技术:AspectJ 的底层技术是静态代理,即用一种AspectJ 支持的特定语言编写切面,通过一个命令来编译,生成一个新的代理类,该代理类增强 了业务类,这是在编译时增i强,相对于下面说的运行时增强,编译时增强的性能更好。
    2)、Spring AOP : Spring AOP 采用的是动态代理,在运行期间对业务方法进行增强,所以不会生成新类,对于动态代理技术,Spring AOP 提供了对 JDK 动态代理 的支持以及 CFLib的支持。
    JDK 动态代理只能为接口创建动态代理实力,而不能对类创建动态代理。需要获得被目标类的接口信息(应用 JAVA 的反射技术),生成一个实现了代理接口的动 态代理类(字节码),再通过反射机制获得动态代理类的构造函数,利用构造函数生成动态代理类的实例对象,在调用具体方法前调用 invokeHandler 方法来处理。
    CGLib 动态代理需要依赖ASM包,把代理对象类的 class 文件加载进来,修改其字节码生成子类。
    但是 Spring AOP 基于注解配置的情况下,需要依赖于 AspectJ 包的标准注解,但是不需要额外的编译以及 AspectJ 的植入器,而基于 XML 配置不需要。

    二十、说说你对Spring的理解
    Spring是一个优秀的轻量级框架,大大的提高了项目的开发管理与维护。Spring有两个核心模块。一个是IOC,一个是AOP。
    IOC: 就是控制反转的意思,指的是我们将对象的控制权从应用代码本身转移到外部容器。通过IOC容器在程序运行期间基于JAVA反射机制
    动态的创建对象,配置对象,建立对象之间的依赖关系,管理对象的生命周期。而DI作为依赖注入,是实现IOC控制反转的一种手段。常见的依赖注入方式有:set方式注入和构造器方式注入。通过依赖注入在程序运行期间动态的注入依赖对象,建立对象之间的依赖关系,降低对象之间的耦合度。
    AOP:面向切面编程,是对面向对象编程的补充。我们将通用的业务功能代码块封装起来作为切面,通过指定切入点,也就是指定切面作用的目标方法,最后通过不同类型的通知,告诉容器在调用目标方法的什么时机插入切面代码块。像Spring的声明式事物管理就是基于AOP,在程序运行期间,通过动态代理技术
    给service层的bean追加事物管理,保证事物的ACID特性。我们可以通过AOP将一些任务单独封装,通过动态代理技术,在不改变原有代码的情况下追加功能,提高代码的复用和简化编程。
    Spring还提供了很多优秀的插件,像springmvc,springjdbc,springorm等等
    除此之后spring还可以用来集成其他优秀的框架,像mybatis,hibernate,struts等等。

    二十一、spring有几种依赖注入方式
    (1)Set方法注入;
    (2)构造器注入:①通过index设置参数的位置;②通过type设置参数类型;
    (3)静态工厂注入;
    (4)实例工厂;

    二十二、spring容器的bean什么时候被实例化?
    第一:如果你使用BeanFactory作为Spring Bean的工厂类,则所有的bean都是在第一次使用该Bean的时候实例化
    第二:如果你使用ApplicationContext作为Spring Bean的工厂类,则又分为以下几种情况:
    (1):如果bean的scope是singleton的,并且lazy-init为false(默认是false,所以可以不用设置),则 ApplicationContext启动的时候就实例化该Bean,并且将实例化的Bean放在一个map结构的缓存中,下次再使 用该 Bean的时候,直接从这个缓存中取
    (2):如果bean的scope是singleton的,并且lazy-init为true,则该Bean的实例化是在第一次使用该Bean的时候进 行实例化
    (3):如果bean的scope是prototype的,则该Bean的实例化是在第一次使用该Bean的时候进行实例化

    二十三、spring中用到了哪些涉及模式
    1.工厂模式,这个很bai明显,在各种BeanFactory以及ApplicationContext创建中都用到了du;
    2.模版zhi模式,这个也很明显,在各种BeanFactory以及daoApplicationContext实现中也都用到了;
    3.代理模式,在Aop实现中用到了JDK的动态代理;
    4.策略模式,第一个地方,加载资源文件的方式,使用了不同的方法,比如:ClassPathResourece,FileSystemResource,ServletContextResource,UrlResource但他们都有共同的借口Resource;第二个地方就是在Aop的实现中,采用了两种不同的方式,JDK动态代理和CGLIB代理;
    5.单例模式,这个比如在创建bean的时候。

    ##springmvc
    一、什么是springmvc
    首先是一个MVC框架。在web模型中,MVC是一种很流行的框架,通过把Model,View,Controller分离,把较为复杂的web应用分成逻辑清晰的几部分,是为了简化开发,减少出错。还是为了组内开发人员之间的配合。总之就是一种分层工作的办法。
    springMVC,是spring的一个子框架,当然拥有spring的特性,如依赖注入。
    Spring下的子项目:Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架,即使用了MVC架构模式的思想,将web层进行职责解耦,基于请求驱动指的就是使用请求-响应模型,框架的目的就是帮助我们简化开发,Spring Web MVC也是要简化我们日常Web开发的。

    二、springmvc里有哪些组件,哪几个是核心
    SpringMVC 的五大核心组件:
      1)、DispatcherServlet 请求的入口
      2)、HandlerMapping 请求的派发 负责让请求 和 控制器建立一一对应的关联
      3)、Controller 真正的处理器
      4)、ModelAndView 封装模型信息和视图信息的
      5)、ViewResolver 视图处理器 最终定位页面的

    三、SpringMVC中的拦截器和Servlet中的filter有什么区别?

    具体区别:

    filterinterceptor
    多个的执行顺序根据filter mapping配置的先后顺序按照配置的顺序,但是可以通过order控制顺序
    规范在Servlet规范中定义的,是Servlet容器支持的Spring容器内,是Spring框架支持的
    使用范围只能用于Web程序中既可以用于Web程序,也可以用于Application、Swing程序中
    深度filter只在Servlet前后起作用拦截器能够深入到方法前后、异常抛出前后等

    两者的本质区别:拦截器是基于java的反射机制的,而过滤器是基于函数回调。从灵活性上说拦截器功能更强大些,Filter能做的事情,他都能做,而且可以在请求前,请求后执行,比较灵活。Filter主要是针对URL地址做一个编码的事情、过滤掉没用的参数、安全校验(比较泛的,比如登录不登录之类),太细的话,还是建议用interceptor。不过还是根据不同情况选择合适的。

    四、SpringMVC 工作原理、执行流程
    简单来说:客户端发送请求-> 前端控制器 DispatcherServlet 接受客户端请求 -> 找到处理器映射 HandlerMapping 解析请求对应的 Handler -> HandlerAdapter 会根据 Handler 来调用真正的处理器来处理请求,并处理相应的业务逻辑 -> 处理器返回一个模型视图 ModelAndView -> 视图解析器进行解析 -> 返回一个视图对象 -> 前端控制器 DispatcherServlet 渲染数据(Model)-> 将得到视图对象返回给用户.
    在这里插入图片描述

    上图用于辅助理解,面试时可用下列 8 步描述 SpringMVC 运行流程:
    

    1)、用户向服务器发送请求,请求被 Spring 前端控制Servelt DispatcherServlet 捕获;

    2)、DispatcherServlet 对请求 URL 进行解析,得到请求资源标识符(URI).然后根据该 URI,调用 HandlerMapping 获得该 Handler 配置的所有相关的对象(包括 Handler 对象以及 Handler 对象对应的拦截器),最后以 HandlerExecutionChain 对象的形式返回;

    3)、DispatcherServlet 根据获得的 Handler,选择一个合适的HandlerAdapter;(附注:如果成功获得HandlerAdapter 后,此时将开始执行拦截器的 preHandler(…)方法)

    4)、提取 Request 中的模型数据,填充 Handler 入参,开始执行Handler(Controller).在填充 Handler 的入参过程中,根据你的配置,Spring 将帮你做一些额外的工作:

    (1)HttpMessageConveter:将请求消息(如:Json、xml 等数据)转换成一个对象,将对象转换为指定的响应信息;

    (2)数据转换:对请求消息进行数据转换.如:String 转换成 Integer、Double 等;

    (3)数据格式化:对请求消息进行数据格式化.如:将字符串转换成格式化数字或格式化日期等;

    (4)数据验证:验证数据的有效性(长度、格式等),验证结果存储到 BindingResult 或 Error 中;

    5)、Handler 执行完成后,向 DispatcherServlet 返回一个 ModelAndView 对象;

    6)、根据返回的 ModelAndView,选择一个适合的 ViewResolver(必须是已经注册到 Spring 容器中的 ViewResolver)返回给DispatcherServlet;

    7)、ViewResolver 结合 Model 和 View,来渲染视图;

    8)、将渲染结果返回给客户端.

    五、Springmvc 中DispatcherServlet初始化过程
    1、封装及安正初始化参数,主要是对初始化的参数进行封装
    2、将当前servlet实例转化成BeanWrapper
    3、注册相对应Resource的属性编辑器
    4、属性注入
    5、servletBean的初始化
    1)、通过构造函数的注入进行初始化
    2)、通过contextAttribute进行初始化
    3)、重新创建WebApplicationContext实例

    六、springmvc中怎么定义异常处理
    可以将异常抛给Spring框架,由Spring框架来处理;我们只需要配置简单的异常处理器,在异常处理器中添视图页面即可

    七、怎么定义拦截器
    1)、定义拦截器,实现HandlerInterceptor接口。接口中提供三个方法。
    1)、preHandle :进入 Handler方法之前执行,用于身份认证、身份授权,比如身份认证,如果认证通过表示当前用户没有登陆,需要此方法拦截不再向下执行
    2)、postHandle:进入Handler方法之后,返回modelAndView之前执行,应用场景从modelAndView出发:将公用的模型数据(比如菜单导航)在这里传到视图,也可以在这里统一指定视图
    3)、afterCompletion:执行Handler完成执行此方法,应用场景:统一异常处理,统一日志处理
    2)、拦截器配置:
    1)、针对HandlerMapping配置(不推荐):springmvc拦截器针对HandlerMapping进行拦截设置,如果在某个HandlerMapping中配置拦截,经过该 HandlerMapping映射成功的handler最终使用该 拦截器。(一般不推荐使用)
    2)、类似全局的拦截器:springmvc配置类似全局的拦截器,springmvc框架将配置的类似全局的拦截器注入到每个HandlerMapping中

    展开全文
  • SSM面试题

    千次阅读 多人点赞 2019-07-11 19:13:58
    一、Spring面试题 1、Spring 在ssm中起什么作用? 作用:Bean工厂,用来管理Bean的生命周期和框架集成。 两大核心: ①. IOC/DI(控制反转/依赖注入) :把dao依赖注入到service层,service层反转给action层,Spring...

    一、Spring面试题
    1、Spring 在ssm中起什么作用?
    作用:Bean工厂,用来管理Bean的生命周期和框架集成。
    两大核心:
    ①. IOC/DI(控制反转/依赖注入) :把dao依赖注入到service层,service层反转给action层,Spring顶层容器为BeanFactory。
    ②. AOP:面向切面编程

    2、Spring的事务?
    编程式事务管理:编程方式管理事务,极大灵活性,难维护。
    声明式事务管理:可以将业务代码和事务管理分离,用注解和xml配置来管理事务。

    3、IOC 在项目中的作用?
    作用:Ioc解决对象之间的依赖问题,把所有Bean的依赖关系通过配置文件或注解关联起来,降低了耦合度。

    4、Spring的配置文件中的内容?
    开启事务注解驱动
    事务管理器
    开启注解功能,并配置扫描包
    配置数据库
    配置SQL会话工厂,别名,映射文件
    不用编写Dao层的实现类

    5、Spring下的注解?
    注册:@Controller @Service @Component
    注入:@Autowired @Resource
    请求地址:@RequestMapping
    返回具体数据类型而非跳转:@ResponseBody

    6、Spring DI 的三种方式?
    构造器注入:通过构造方法初始化

    setter方法注入:通过setter方法初始化

    接口注入

    7、Spring主要使用了什么模式?
    工厂模式:每个Bean的创建通过方法
    单例模式:默认的每个Bean的作用域都是单例
    代理模式:关于Aop的实现通过代理模式

    8、IOC,AOP的实现原理?
    IOC:通过反射机制生成对象注入
    AOP:动态代理

    二、SpringMvc面试题
    1、SpringMvc 的控制器是不是单例模式,如果是,有什么问题,怎么解决?
    问题:单例模式,在多线程访问时有线程安全问题
    解决方法:不要用同步,在控制器里面不能写字段

    2、SpringMvc 中控制器的注解?
    @Repository:用于注解dao层,在daoImpl类上面注解。

    @Controller:该注解表明该类扮演控制器的角色

    @RequestMapping:RequestMapping是一个用来处理请求地址映射的注解,可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。
    RequestMapping注解有六个属性,下面我们把她分成三类进行说明(下面有相应示例):
    1) value, method;
    value: 指定请求的实际地址,指定的地址可以是URI Template 模式(后面将会说明);
    method: 指定请求的method类型, GET、POST、PUT、DELETE等;
    2)consumes,produces
    consumes: 指定处理请求的提交内容类型(Content-Type),例如application/json, text/html;
    produces: 指定返回的内容类型,仅当request请求头中的(Accept)类型中包含该指定类型才返回;
    3、params,headers
    params: 指定request中必须包含某些参数值是,才让该方法处理。

    @ResponseBody:作用: 该注解用于将Controller的方法返回的对象,通过适当的HttpMessageConverter转换为指定格式后,写入到Response对象的body数据区。
    使用时机:返回的数据不是html标签的页面,而是其他某种格式的数据时(如json、xml等)使用;

    2、2. Spring MVC的工作原理
    1、用户发送请求至前端控制器DispatcherServlet
    2、DispatcherServlet收到请求调用HandlerMapping处理器映射器。
    3、处理器映射器找到具体的处理器,生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。
    4、DispatcherServlet调用HandlerAdapter处理器适配器
    5、HandlerAdapter经过适配调用具体的处理器(Controller,也叫后端控制器)。
    6、Controller执行完成返回ModelAndView
    7、HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet
    8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器
    9、ViewReslover解析后返回具体View
    10、DispatcherServlet根据View进行渲染视图(即将模型数据填充至视图中)。
    11、DispatcherServlet响应用户

    4、前台多个参数,这些参数都是一个对象,快速得到对象?
    方法:直接在方法中声明这个对象,SpringMvc就自动把属性赋值到这个对象里面

    5、SpringMvc中函数的返回值?
    String,ModelAndView,List,Set 等
    一般String,Ajax请求,返回一个List集合

    6、SpringMvc中的转发和重定向?
    转发: return:“hello”
    重定向 :return:“redirect:hello.jsp”

    7、SpringMvc和Ajax之间的相互调用?
    通过JackSon框架把java里面对象直接转换成js可识别的json对象,具体步骤如下:

    加入JackSon.jar
    在配置文件中配置json的映射
    在接受Ajax方法里面直接返回Object,list等,方法前面需要加上注解@ResponseBody

    8、SpringMvc的工作流程图?

    9、Struts2 和 SpringMvc的区别?
    入口不同:
    Struts2:filter过滤器
    SpringMvc:一个Servlet即前端控制器

    开发方式不同:
    Struts2:基于类开发,传递参数通过类的属性,只能设置为多例
    SpringMvc:基于方法开发(一个url对应一个方法),请求参数传递到方法形参,可以为单例也可以为多例(建议单例)
    请求方式不同:
    Struts2:值栈村塾请求和响应的数据,通过OGNL存取数据
    SpringMvc:通过参数解析器将request请求内容解析,给方法形参赋值,将数据和视图封装成ModelAndView对象,最后又将ModelAndView中的模型数据通过request域传输到页面,jsp视图解析器默认使用的是jstl。

    三、Mybatis面试题

    1、什么是Mybatis的接口绑定,有什么好处?
    Mybatis实现了DAO接口与xml映射文件的绑定,自动为我们生成接口的具体实现,使用起来变得更加省事和方便。

    2、什么情况用注解,什么情况用xml绑定?
    注解使用情况:Sql语句简单时
    xml绑定使用情况:xml绑定 (@RequestMap用来绑定xml文件)

    3、Mybatis在核心处理类叫什么?
    SqlSession

    4、查询表名和返回实体Bean对象不一致,如何处理?
    映射键值对即可

    column:数据库中表的列名
    property:实体Bean中的属性名

    5、Mybatis的好处?
    把Sql语句从Java中独立出来。
    封装了底层的JDBC,API的调用,并且能够将结果集自动转换成JavaBean对象,简化了Java数据库编程的重复工作。
    自己编写Sql语句,更加的灵活。
    入参无需用对象封装(或者map封装),使用@Param注解

    6、Mybatis配置一对多?

    property:属性名
    column:共同列
    ofType:集合中元素的类型
    select:要连接的查询

    7、Mybatis配置一对一?

    property:属性名
    select:要连接的查询
    column:共同列
    javaType:集合中元素的类型

    8、${} 和 #{}的区别?
    : 简 单 字 符 串 替 换 , 把 {}:简单字符串替换,把 {}直接替换成变量的值,不做任何转换,这种是取值以后再去编译SQL语句。
    #{}:预编译处理,sql中的#{}替换成?,补全预编译语句,有效的防止Sql语句注入,这种取值是编译好SQL语句再取值。
    总结:一般用#{}来进行列的代替

    9、获取上一次自动生成的主键值?
    select last _insert_id()

    10、Mybatis如何分页,分页原理?
    RowBounds对象分页
    在Sql内直接书写,带有物理分页

    11、Mybatis工作原理?
    原理:
    通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件中构建出SqlSessionFactory。
    SqlSessionFactory开启一个SqlSession,通过SqlSession实例获得Mapper对象并且运行Mapper映射的Sql语句。
    完成数据库的CRUD操作和事务提交,关闭SqlSession。

    展开全文
  • javaSSM面试题

    2020-08-10 13:24:21
    我用#CSDN#这个app发现了有技术含量的博客,小伙伴们求同去《JavaSSM框架精选50道面试题》, 一起来围观吧 https://blog.csdn.net/qq_41735004/article/details/87199651

    我用#CSDN#这个app发现了有技术含量的博客,小伙伴们求同去《JavaSSM框架精选50道面试题》, 一起来围观吧 https://blog.csdn.net/qq_41735004/article/details/87199651

    展开全文
  • SSM面试题总结(含答案)

    万次阅读 多人点赞 2019-04-26 08:07:12
    一、Spring面试题 1、Spring 在ssm中起什么作用? Spring:轻量级框架 作用:Bean工厂,用来管理Bean的生命周期和框架集成。 两大核心: ①. IOC/DI(控制反转/依赖注入) :把dao依赖注入到service层,service层反转...

    一、Spring面试题

    1、Spring 在ssm中起什么作用?

    Spring:轻量级框架

    作用:Bean工厂,用来管理Bean的生命周期和框架集成。

    两大核心:

    ①. IOC/DI(控制反转/依赖注入) :把dao依赖注入到service层,service层反转给action层,Spring顶层容器为BeanFactory。

    ②. AOP:面向切面编程

    2、Spring的事务?

    编程式事务管理:编程方式管理事务,极大灵活性,难维护。

    声明式事务管理:可以将业务代码和事务管理分离,用注解和xml配置来管理事务。

    3、IOC 在项目中的作用?

    作用:Ioc解决对象之间的依赖问题,把所有Bean的依赖关系通过配置文件或注解关联起来,降低了耦合度。

    4、Spring的配置文件中的内容?

    开启事务注解驱动

    事务管理器

    开启注解功能,并配置扫描包

    配置数据库

    配置SQL会话工厂,别名,映射文件

    不用编写Dao层的实现类

    5、Spring下的注解?

    注册:@Controller @Service @Component

    注入:@Autowired @Resource

    请求地址:@RequestMapping

    返回具体数据类型而非跳转:@ResponseBody

    6、Spring DI 的三种方式?

    构造器注入:通过构造方法初始化

    <constructor-arg index="0" type="java.lang.String" value="宝马"></constructor-arg>
    

    setter方法注入:通过setter方法初始化

    <property name="id" value="1111"></property>
    

    接口注入

    7、Spring主要使用了什么模式?

    工厂模式:每个Bean的创建通过方法

    单例模式:默认的每个Bean的作用域都是单例

    代理模式:关于Aop的实现通过代理模式

    8、IOC,AOP的实现原理?

    IOC:通过反射机制生成对象注入

    AOP:动态代理

    二、SpringMvc面试题

    1、SpringMvc 的控制器是不是单例模式,如果是,有什么问题,怎么解决?

    问题:单例模式,在多线程访问时有线程安全问题

    解决方法:不要用同步,在控制器里面不能写字段

    2、SpringMvc 中控制器的注解?

    @Controller:该注解表明该类扮演控制器的角色

    3、@RequestMapping 注解用在类上的作用?

    作用:用来映射一个URL到一个类或者一个特定的处理方法上

    4、前台多个参数,这些参数都是一个对象,快速得到对象?

    方法:直接在方法中声明这个对象,SpringMvc就自动把属性赋值到这个对象里面

    5、SpringMvc中函数的返回值?

    String,ModelAndView,List,Set 等

    一般String,Ajax请求,返回一个List集合

    6、SpringMvc中的转发和重定向?

    转发: return:“hello”

    重定向 :return:“redirect:hello.jsp”

    通过JackSon框架把java里面对象直接转换成js可识别的json对象,具体步骤如下:

    加入JackSon.jar

    在配置文件中配置json的映射

    在接受Ajax方法里面直接返回Object,list等,方法前面需要加上注解@ResponseBody

    8、SpringMvc的工作流程图?

    9、Struts2 和 SpringMvc的区别?

    入口不同:

    Struts2:filter过滤器

    SpringMvc:一个Servlet即前端控制器

    开发方式不同:

    Struts2:基于类开发,传递参数通过类的属性,只能设置为多例

    SpringMvc:基于方法开发(一个url对应一个方法),请求参数传递到方法形参,可以为单例也可以为多例(建议单例)

    请求方式不同:

    Struts2:值栈村塾请求和响应的数据,通过OGNL存取数据

    SpringMvc:通过参数解析器将request请求内容解析,给方法形参赋值,将数据和视图封装成ModelAndView对象,最后又将ModelAndView中的模型数据通过request域传输到页面,jsp视图解析器默认使用的是jstl。

    三、Mybatis面试题

    1、Ibatis和Mybatis?

    Ibatis:2010年,apache的Ibatis框架停止更新,并移交给了google团队,同时更名为MyBatis。从2010年后Ibatis在没更新过,彻底变成了一个孤儿框架。一个没人维护的框架注定被mybatis拍在沙滩上。

    Mybatis:Ibatis的升级版本。

    2、什么是Mybatis的接口绑定,有什么好处?

    Mybatis实现了DAO接口与xml映射文件的绑定,自动为我们生成接口的具体实现,使用起来变得更加省事和方便。

    3、什么情况用注解,什么情况用xml绑定?

    注解使用情况:Sql语句简单时

    xml绑定使用情况:xml绑定 (@RequestMap用来绑定xml文件)

    4、Mybatis在核心处理类叫什么?

    SqlSession

    5、查询表名和返回实体Bean对象不一致,如何处理?

    映射键值对即可

    <result column="title" property="title" javaType="java.lang.String"/>
    

    column:数据库中表的列名

    property:实体Bean中的属性名

    6、Mybatis的好处?

    把Sql语句从Java中独立出来。

    封装了底层的JDBC,API的调用,并且能够将结果集自动转换成JavaBean对象,简化了Java数据库编程的重复工作。

    自己编写Sql语句,更加的灵活。

    入参无需用对象封装(或者map封装),使用@Param注解

    7、Mybatis配置一对多?

    <collection property="topicComment" column="id" ofType="com.tmf.bbs.pojo.Comment" select="selectComment" />
    

    property:属性名

    column:共同列

    ofType:集合中元素的类型

    select:要连接的查询

    8、Mybatis配置一对一?

    <association property="topicType" select="selectType" column="topics_type_id" javaType="com.tmf.bbs.pojo.Type"/>
    

    property:属性名

    select:要连接的查询

    column:共同列

    javaType:集合中元素的类型

    9 、${} 和 #{}的区别?

    : 简 单 字 符 串 替 换 , 把 {}:简单字符串替换,把 {}直接替换成变量的值,不做任何转换,这种是取值以后再去编译SQL语句。

    #{}:预编译处理,sql中的#{}替换成?,补全预编译语句,有效的防止Sql语句注入,这种取值是编译好SQL语句再取值。

    总结:一般用#{}来进行列的代替

    10、获取上一次自动生成的主键值?

    select last _insert_id()
    

    11、Mybatis如何分页,分页原理?

    RowBounds对象分页

    在Sql内直接书写,带有物理分页

    12、Mybatis工作原理?

    image

    原理:

    通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件中构建出SqlSessionFactory。

    SqlSessionFactory开启一个SqlSession,通过SqlSession实例获得Mapper对象并且运行Mapper映射的Sql语句。

    完成数据库的CRUD操作和事务提交,关闭SqlSession。


    扫描下方二维码,及时获取更多互联网求职面经javapython爬虫大数据等技术,和海量资料分享
    公众号**菜鸟名企梦后台发送“csdn”即可免费领取【csdn】和【百度文库】下载服务;
    公众号
    菜鸟名企梦后台发送“资料”:即可领取5T精品学习资料**、java面试考点java面经总结,以及几十个java、大数据项目资料很全,你想找的几乎都有
    扫码关注,及时获取更多精彩内容。(博主今日头条大数据工程师)

    推荐阅读

    二叉树高频面试题总结:含答案

    展开全文
  • SSM面试题及相关答案

    千次阅读 多人点赞 2020-03-10 16:42:47
    Spring在SSM中起什么作用 作用:Bean工厂,用来管理Bean的生命周期和框架集成。 两大核心:(1)IOC/DI(控制反转/依赖注入),Spring顶层容器为BeanFactory(2)AOP(面向切面编程) 13. IOC在项目中的作用 IOC解决对象...
  • ssm面试题总结 spring springmvc面试题 理解spring

    万次阅读 多人点赞 2018-06-05 19:08:33
    Spring在SSM起什么作用 Spring是一个轻量级框架,也是一个容器,Spring实质上讲就是一个Bean工厂,主要用来管理Bean的生命周期和框架集成。有IOC控制反转,DI依赖注入,控制反转是把dao依赖注入到servic层,然后...
  • 精心梳理二十二道常见SSM面试题(带答案) 前言: 最近好多人问我要SSM的资料,所以小编也精心整理了一些ssm的面试题给大家,希望可以帮助到大家,由于篇幅限制,只有十题的答案在文中,后面的答案,关注我的...
  • Java SSM面试题

    2019-03-23 15:11:07
    一、Spring面试题 1、Spring 在ssm中起什么作用? Spring:轻量级框架 作用:Bean工厂,用来管理Bean的生命周期和框架集成。 两大核心: 1、IOC/DI(控制反转/依赖注入) :把dao依赖注入到service层,service层反转...
  • 2、狂刷面试题 技术主要是体现在平时的积累实用,面试前准备两个月的时间再好好复习一遍,紧接着就可以刷面试题了,下面这些面试题都是小编精心整理的,贴给大家看看。 ①大厂高频45道笔试题(智商题) ②BAT大厂...
  • 为了准备这个“金三银四”的春招,狂刷一个月的题,狂补超多的漏洞知识,像这次美团面试问的算法、数据库、Redis、设计模式等这些题目都是我刷到过的 CodeChina开源项目:【一线大厂Java面试题解析+核心总结学习...
  • SSM 梳理 面试题整理

    2018-10-04 20:01:14
    该文档主要整理的是SSM的常见面试题,包括一下内容: 1. SpringMVC 的工作原理 (11步) 2. 谈谈你对SpringMVC的理解 3. SpringMVC 常用注解都有哪些? 4. Spring 的常用注解 5. 如何开启注解处理器和适配器? 6...
  • SSM面试题 1、#{}和¥{}的区别? ${}会产生SQL注入,#{}不会产生SQL注入问题 #{}匹配的是一个占位符,相当于JDBC中的一个?,会对一些敏感的字符进行过滤,编译过后会对传递的值加上双引号,因此可以防止SQL注入问题...
  • ssm面试题整理

    2020-06-21 17:09:29
    spring的优点: spring易于集合其他框架 spring的核心 spring我经常用到的两个核心就是IOC 和 AOP IOC主要是负责维护管理对象和解耦 底层: ioc的底层是一个MAP容器 使用工厂模式BeanFactory Properties读取配置...
  • java常见面试考点 往期文章推荐:   java常见面试考点(四):方法的参数传递机制   java常见面试考点(五):基本类型和包装类型的区别   java常见面试考点(六):深入理解String类型   java常见面试考点...
  • SSM面试题整理

    2019-07-02 22:09:57
    文章目录SSMSpringSpring 在SSM中起什么作用?Spring的事务?IOC在项目中的作用?Spring的配置文件中的内容?Spring下的注解?Spring DI的三种方式?Spring主要使用了什么模式?IOC,AOP的实现原理?...
  • (1) Spring在SSM起什么作用 Spring是一个轻量级框架,也是一个容器,Spring实质上讲就是一个Bean工厂,主要用来管理Bean的生命周期和框架集成。有IOC控制反转,DI依赖注入,控制反转是把dao依赖注入到servic层,...
  • <!-- ★bean的作用域 可以通过scope属性来指定bean的作用域 -singleton:默认值。当IOC容器一创建就会创建bean的实例,而且是单例的,每次得到的都是同一个 -prototype:原型的。当IOC容器一创建不再实例...
  • 2016最新ssm面试题

    万次阅读 2017-02-05 16:26:34
    1.很新的面试题;2.很全的面试题;3.很重点的面试题框架;Struts2与Struts1的面试题;###1.Struts2与Struts1的联系与;struts1与struts2都是mvc框架的经;Struts2不是从Struts1升级而来,而是;区别:;1.核心控制器...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,095
精华内容 3,638
关键字:

ssm面试题