SSH框架总结

*mybatis设置主键自增长>>点击打开链接

mybatis传入多个参数>>点击打开链接

mybatis中同一个mapper中的多个查询为什么是启用多个sqlSession来处理的？>>点击打开链接

mybatis使用的一点小结：session运行模式及批量提交>>mybatis使用的一点小结：session运行模式及批量提交>>点击打开链接

关于Mybatis的Batch模式性能测试及结论>>点击打开链接

mybatis中批量插入的两种方式(高效插入)>>点击打开链接

mybatis使用association一对一关联查询>>点击打开链接

mybatis使用collection多对多/一对多关联查询>>点击打开链接

mybatis配置懒加载

<settings>
	<setting name="mapUnderscoreToCamelCase" value="true"/>
	<!-- 开启懒加载机制 ,默认值为true-->
	<setting name="lazyLoadingEnabled" value="true"/>
	<!-- 开启的话，每个属性都会直接全部加载出来；禁用的话，只会按需加载出来 -->
	<setting name="aggressiveLazyLoading" value="false"/>
</settings>

mybatis注解方式查询>>点击打开链接

mybatis增强注解>>点击打开链接

MyBatis注解方式>>点击打开链接>>点击打开链接

mybatis动态添加字段需要添加在<select>标签中开启预编译，即statementType=“STATEMENT”,而且，在引用的时候只能使用$,而不能使用#,且jdbcType不能添加（这很重要，我就是因为前面的步骤都对了，最后卡在这里一个下午）

mybatis批量更新(1)>>原文内容

mybatis批量更新(2)>>原文内容

 

如果你搜索只是返回一个值，比如说String ，或者是int，那你直接用resultType就行了。
但是你如果是返回一个复杂的对象，就必须定义好这个对象的resultMap的result map。

 

*每个线程都应该有它自己的SqlSession实例。SqlSession的实例不能共享使用，它也是线程不安全的。因此最佳的范围是请求或方法范围。绝对不能将SqlSession实例的引用放在一个类的静态字段或实例字段中。 

*在SqlSession接口调用的insert/update/delete方法中，所有的操作都交给了Executor来操作。SqlSession接口是Mybatis框架暴露的外部接口，而Executor是内部的实现接口。在Executor的实现中，又是调用StatementHandler来处理的。当然，在调用StatementHandler设置参数时候，需要ParameterHandler来设置相应的参数

 

*MyBatis常用对象SqlSessionFactory和SqlSession介绍和运用>>点击打开链接

*Mybatis使用foreach批量插入不同的数据库插入方法不一致

mysql

oracle

 

*Mybatis关联查询之一对多和多对一XML配置详解>>点击打开链接

 

*Spring中@param和mybatis中@param使用区别>>原文内容

*浅谈@RequestMapping @ResponseBody 和 @RequestBody 注解的用法与区别>>原文内容

*@RequestBody 的正确使用办法>>原文内容

*@Controller和@RestController的区别>>原文内容

 

*Hibernate一级缓存默认打开，二级缓存默认关闭，有两种方法可以打开，其一：通过@Cache在对应的实体类上添加@Cache注解即可，其二：在配置文件中加入了<prop key=”javax.persistence.sharedCache.mode”>ENABLE_SELECTIVE</prop>，三级缓存需要结合redis等第三方框架使用

 

一、预备知识：@RequestMapping
RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。
用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。


@RequestMapping(value = "/aaa")//类级别,可以没有
public class myController {
    @RequestMapping(value = "/bbb")//方法级别,必须有
    public String getMyName() {
        return "myReturn";
    }
}


对应的action就是：<form action="aaa/bbb">
返回页面就是myReturn.jsp


二、@Responsebody与@RequestBody
@Responsebody 表示该方法的返回结果直接写入 HTTP response body 中
一般在异步获取数据时使用，在使用 @RequestMapping 后，返回值通常解析为跳转路径，
加上 @Responsebody 后返回结果不会被解析为跳转路径，而是直接写入 HTTP response body 中。
比如异步获取json数据，加上 @Responsebody 后，会直接返回json数据。


@RequestBody 将 HTTP 请求正文插入方法中,使用适合的 HttpMessageConverter 将请求体写入某个对象。
function login() {//页面异步请求
    var mydata = '{"name":"' + $('#name').val() + '","id":"'
            + $('#id').val() + '","status":"' + $('#status').val() + '"}';
    $.ajax({
        type : 'POST',
        contentType : 'application/json',
        url : "${pageContext.request.contextPath}/person/login",
        processData : false,
        dataType : 'json',
        data : mydata,
        success : function(data) {
            alert("id: " + data.id + "\nname: " + data.name + "\nstatus: "
                    + data.status);
        },
        error : function() {
            alert('出错了！');
        }
    });
};


@RequestMapping(value = "person/login")
@ResponseBody
public Person login(@RequestBody Person person) {//将请求中的mydata写入Person对象中
   return person;//不会被解析为跳转路径，而是直接写入HTTP response body中
}


三、扩展：@PathVariable获取请求路径变量


function profile() {
    var url = "${pageContext.request.contextPath}/person/profile/";
    var query = $('#id').val() + '/' + $('#name').val() + '/'
            + $('#status').val();
    url += query;
    $.get(url, function(data) {
        alert("id: " + data.id + "\nname: " + data.name + "\nstatus: "
                + data.status);
    });
}


@RequestMapping(value = "person/profile/{id}/{name}/{status}")
@ResponseBody
public Person porfile(@PathVariable int id,@PathVariable String name,@PathVariable boolean status) {
    return new Person(id, name, status);
}
//@RequestMapping(value = "/person/profile/{id}/{name}/{status}")中的{id}/{name}/{status}与@PathVariable int id, @PathVariable String name,@PathVariable boolean status一一对应，按名匹配。

 

*@responseBody注解说明

1、


　　@responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML


　　数据，需要注意的呢，在使用此注解之后不会再走试图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。


2、　　


　　@RequestMapping("/login")
　　@ResponseBody
　　public User login(User user){
　　　　return user;
　　}
　　User字段：userName pwd
　　那么在前台接收到的数据为：'{"userName":"xxx","pwd":"xxx"}'


　　效果等同于如下代码：
　　@RequestMapping("/login")
　　public void login(User user, HttpServletResponse response){
　　　　response.getWriter.write(JSONObject.fromObject(user).toString());
　　}

 

*如果一个列允许 null 值，并且会传递值 null 的参数，就必须要指定 JDBC Type。阅读 PreparedStatement.setNull() 的 JavaDocs 文档来获取更多信息。

 

*MyBatis 通过包含的jdbcType类型 
BIT FLOAT CHAR TIMESTAMP OTHER UNDEFINED

TINYINT REAL VARCHAR BINARY BLOB NVARCHAR

SMALLINT DOUBLE LONGVARCHAR VARBINARY CLOB NCHAR

INTEGER NUMERIC DATE LONGVARBINARY BOOLEAN NCLOB

BIGINT DECIMAL TIME NULL CURSOR

 

 

 

*Spring 控制反转怎么体现

考虑一下我们之前在程序中如果需要一个对象会怎么办？一般是使用new关键字，然后后面接一个类，调用构造方法，这样jvm就会给我们生产一个对象。也就是说程序员需要对象的时候完全是自己new的，比如 Person person = new Person();

可是有了Spring之后，我们的对象完全交给Spring去管理类，我们直接在Spring的配置文件里配置好Bean，就可以放心大胆的不用管了.比如如下配置代码：

1 2 3

<bean id="person" class="com.wyq.Spring.Person"> <property name="age" value="12" /> <property name="name" value="Tom"/>

然后接下来，我们要使用这个Bean的时候该怎么办呢？只需要这样一个方法：

1 2	ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml"); Person person = ctx.getBean("person",Person.class);

如上图，这样的peron实例对象就由Spring管理的，关于它是生命周期，如何生产你完全不用管，用的时候直接调用Spring提供的方法就行。

这就是控制反转的体现，把对象实例化交给Spring去控制，程序员并不用管。

 

*拦截器和过滤器的区别：拦截器是基于Java的反射机制的，而过滤器是基于函数回调。从灵活性上说拦截器功能更强大些，Filter能做的事情，他都能做，而且可以在请求前，请求后执行，比较灵活，缺点是只能对controller请求进行拦截，对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理。Filter主要是针对URL地址做一个编码的事情、过滤掉没用的参数、安全校验（比较泛的，比如登录不登录之类），太细的话，还是建议用interceptor。不过还是根据不同情况选择合适的。

 

*Restrictions.eqOrIsNull("inName",outName)和Restrictions.and(Restrictions.or(Restrictions.isNull("inName"),Restrictions.eq("inName",outName)))的区别：现设定数据库中参数为inName,外部参数为outName，前者的意思是：在where后加上inName=outName(outName不为空)或者inName IS NULL(outName为空)的条件；后者的意思是：在where后面加上条件（inName IS NULL OR inName=outName）

 

*Hibernate用原生sql查询时应该用占位符替代参数的形式组装sql，如果直接用字符串拼接会遇到两个问题：1，sql注入，存在安全隐患，2，如果该sql语句频繁使用，会导致游标在短时间内占用大量游标且释放缓慢，最终导致游标超过阈值。

 

 - mybatis的sql.xml文件中,parameterType和resultType只能有一个，如果参数有多个，必须使用map和list。

 

 - 如果需要在页面导入很多公共标签最好在一个页面中把需要的公共标签导入，然后其他页面导入此页面即可。如果每个页面都导入那么多公共标签会使得页面看起来臃肿而复杂，破坏可读性。


 - 在web.xml中，spring用listener监听，struts2用filter监听，web.xml启动的顺序是：context-param(设置根目录参数，负责xml文件的加载)>listener>filter>servlet
 
 - Controller可以不必非得用ModelAndView，也可以用String，如果需要带参数必须要传入HttpServletRequestrequest,然后利用request.setAttribute(“result”,result);这种类似的方式插入参数。
 
 - <mvc:annotation-driven/>用于开启SpringMVC的注解功能。可以简化原来用两个类开启注解功能。
 
 - maven坐标命名，构建本地repo需要向package再install


 - controller的两种方法
第一种是类上添加@RequestMapping(value=”save”) ,对应jsp页面写法是save.html
第二种是是在controller类上加上@RequestMapping(value=”indexController”)或者@RequestMapping(”indexController”),类上也加上@RequestMapping(params=”save”)或者@RequestMapping(”save”),注意是params,对应jsp页面写法是indexController.html?save
 
 - dao,service接口不用添加注解,但是dao,service的实现类需要@Repository和@Service,@Transactional
service的实现类如果要调用dao方法添加@Resource,而不必继承dao
 
 - 级联一般用于一对一和一对多.
 
 - 多对一,一对多关系中
在写关联和保存时:被依赖的先写,依赖的后写.一般情况下,一是依赖的,多是被依赖的.
在解除关系时:依赖的一方要解除关系,先要将inverse设置为true.
 
 - HashSet不初始化
privateSet<String> addressSet;
Set<String>set=new HashSet<String>();
set.add(“---”);
Useruser=new User();
user.setAddress(set);
 
HashSet初始化
privateSet<String> addressSet=new HashSet<String>();
Useruser=new User();
user.getAddress().add(“---”);
 
 - HQL语言不能识别select *，一般省略。
 
 - 设置默认的事务隔离级别：
         隔离级别    对应的整数表示
         READ UNCOMMITED 1
         READCOMMITED   2
         REPEATABLEREAD 4
         SERIALIZEABLE   8
在更新或删除之后一般要调用refresh方法更新数据，否则同一个类中第二次取数据无法得到更新后的数据
 
 - 基本数据类型不能作为泛型，如果非要用基本数据类型作为泛型，则只能使用其包装类。
 
 - 用注释实现IOC
按名字自动注入byName等价于@Resource/@Autowired@Qualifier(value=” “)
按类型自动注入byType等价于@AutoWired/@Resource(type=?.class)
 
 - 集合关系,最上面,中间都是接口,最下面是实现类.List和Queue有序可重复,Set无序不可重复的.
 
 - 拿到一个项目如何分析
 
 - 两个类有继承关系才能使用多态
 
 - 返回对象为一个对象的时候如果所需的数据类型为int,可以用intValue()方法,将对象转化为相应的数据类型.
 
 - API
Configuration 配置
  configure()
 configure(String resource)
 addResource(String resource) 导入一个指定位置的映射文件(测试时用)
 addClass(Class.class) 导入与指定类同一个包中的以类名为前缀,后缀为.hbm.xml的文件
 buildSessionFactory() 导入与指定类同一个包中的以类名为前缀,后缀为.hbm.xml文件
 Query
 Critria
SessionFactory Session工厂
 openSession()
 getCurrentSession()
 close()
Session 很重要的一个对象
  操作对象的方法
  save(Object)
 update(Object)
 delete(Object)
  查询的方法
  createQuery(String)
 createCriteria(Class)
  管理事物有关的方法
  beginTransaction()-->Transaction
 getTransaction() -->Transaction获取当前Session中关联的事物对象(例如在try…catch块里不必把Transaction定义为全局变量)
  …
Transaction 事物
  commit()
  rollback()
Query 查询
  list()查询一个结果集合
 uniqueResult()查询一个唯一的结果,如果没有结果,则返回null,如果有多个结果,就抛异常.
…
Hibernate主配置文件
 
1.配置的key前面的hibernate.前缀可以有,也可以没有.如hibernate.dialect或dialect都可以.
2.按作用可分为三类:
         1)数据库信息
           <property …>
          方言,JdbcUrl,驱动,用户名,密码
         2)导入映射文件
           <mapping …>
         3)其他配置
         <property…>
         show_sql显示生成的sql语句
         format_sql格式化生成的sql语句
         hbm2ddl.auto自动生成表结构
生成表结构的两种方式
 - hbm2ddl.auto
2.使用SchemaExport工具类
 
type属性要么为java定义的类型如java.lang.String要么为小写string
当列表与关键字冲突时,可以通过column属性指定一个其他列名或者使用反引号包围起来(不推荐);指定使用text类型是,最好再指定length,以确定生成的SQL类型是能够存放指定数量的数据.
 
 - sql不区分大小写,查询的是表和表中的字段;hql不区分大小写,但是类名和属性名区分大小写
 
 - 三种实例化bean的方式
1,使用类构造器实例化
<bean id=”orderService”class=”cn.itcast.OrderServiceBean”/>
2,使用静态工厂方法实例化
<bean id=”personService”class=”cn.itcast.service.OrderFactory” factory-method=”createOder”>
//factory-method的名字是OrderFactory中创建类的名字
<constructor-orgvalue=”student”></constructor-org>
//静态工厂有参数传递,则要设置constructor-org属性
</bean>
public class OrderFactory{
         publicstatic OrderServiceBean createOrder(){
                   returnnew OrderServiceBean();
         }
}
3,使用实例工厂方法实例化
<bean id=”personServiceFactory”class=” cn.itcast.service.OrderFactory” factory-method=”createOder”/>
public class OrderFactory{
         publicOrderServiceBean createOrder(){
                   returnnew OrderServiceBean();
         }

 

 

}

 

 

*SSH框架概念理解

struts负责客户请求和页面的跳转，把需要处理的内容提交给业务逻辑层（或持久层），获取业务处理后的结果，再把结果返回给客户。
hibernate负责和数据库交互，这个就没啥说的。
spring 主要是负责各层类之间的依赖关联。
SSH框架中，Struts 主要做控制操作，就是页面请求到Struts的Action，在Action中接收请求数据并且处理，然后返回结果再应答给JSP页面，Struts就是一个很完美的MVC结构的开发框架。
Spring的主要技术是IOC和AOP（依赖注入和面向切面）IOC技术主要是帮助类初始化和实例化，并且在Spring中每个类都可以有对应的Bean，在配置文件中，然后把Bean逐层注入到其他应用类。AOP技术主要是做事物处理，一般声明式事物和编程式事物较通用。
Hibernate:就是数据持久化，将数据库中的表映射为相应的实体，以便对实体的操作。
以上都是本人开发中自己总结的。
SSH：Struts（表示层）+Spring（业务层）+Hibernate（持久层）

Struts：
Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。

在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。（View：沿用JSP，HTTP，Form，Tag，Resourse ；Controller：ActionServlet，struts-config.xml，Action）

Hibernate：
Hibernate是一个持久层框架，它只负责与关系数据库的操作。

Spring：
Spring是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。

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


Struts 
为了解决这些问题，出现了Struts框架，它是一个完美的MVC实现，它有一个中央控制类(一个 Servlet)，针对不同的业务，我们需要一个Action类负责页面跳转和后台逻辑运算，一个或几个JSP页面负责数据的输入和输出显示，还有一个 Form类负责传递Action和JSP中间的数据。JSP中可以使用Struts框架提供的一组标签，就像使用HTML标签一样简单，但是可以完成非常复杂的逻辑。从此JSP页面中不需要出现一行包围的Java代码了。 可是所有的运算逻辑都放在Struts的Action里将使得 Action类复用度低和逻辑混乱，所以通常人们会把整个Web应用程序分为三层，Struts负责显示层，它调用业务层完成运算逻辑，业务层再调用持久层完成数据库的读写。 使用JDBC连接来读写数据库，我们最常见的就是打开数据库连接、使用复杂的SQL语句进行读写、关闭连接，获得的数据又需要转换或封装后往外传，这是一个非常烦琐的过程。 

Hibernate 
这时出现了 Hibernate框架，它需要你创建一系列的持久化类，每个类的属性都可以简单的看做和一张数据库表的属性一一对应，当然也可以实现关系数据库的各种表件关联的对应。当我们需要相关操作是，不用再关注数据库表。我们不用再去一行行的查询数据库，只需要持久化类就可以完成增删改查的功能。使我们的软件开发真正面向对象，而不是面向混乱的代码。我的感受是，使用Hibernate比JDBC方式减少了80%的编程量。 现在我们有三个层了，可是每层之间的调用是怎样的呢?比如显示层的Struts需要调用一个业务类，就需要new一个业务类出来，然后使用;业务层需要调用持久层的类，也需要new一个持久层类出来用。通过这种new的方式互相调用就是软件开发中最糟糕设计的体现。简单的说，就是调用者依赖被调用者，它们之间形成了强耦合，如果我想在其他地方复用某个类，则这个类依赖的其他类也需要包含。程序就变得很混乱，每个类互相依赖互相调用，复用度极低。如果一个类做了修改，则依赖它的很多类都会受到牵连。 为此，出现Spring框架。 

Spring
Spring的作用就是完全解耦类之间的依赖关系，一个类如果要依赖什么，那就是一个接口。至于如何实现这个接口，这都不重要了。只要拿到一个实现了这个接口的类，就可以轻松的通过xml配置文件把实现类注射到调用接口的那个类里。所有类之间的这种依赖关系就完全通过配置文件的方式替代了。所以 Spring框架最核心的就是所谓的依赖注射和控制反转。 现在的结构是，Struts负责显示层，Hibernate负责持久层，Spring负责中间的业务层，这个结构是目前国内最流行的Java Web应用程序架构了。另外，由于Spring使用的依赖注射以及AOP(面向方面编程)，所以它的这种内部模式非常优秀，以至于Spring自己也实现了一个使用依赖注射的MVC框架，叫做Spring MVC，同时为了很好的处理事物，Spring集成了Hibernate，使事物管理从Hibernate的持久层提升到了业务层，使用更加方便和强大。 Struts框架是2000年就开始起步了，到目前已经发展了5年，技术相当成熟，目前全球Java开发中Struts框架是显示层技术中当之无愧的王者。它拥有大量的用户群和很好的开发团队。这也是国内大部分Java软件公司对新进员工的基本要求。 其他 Java这个名词似乎注定和开源紧密联系在一起了，在Java界，每天都有大量的开源技术出现，由于是开放源代码的，技术中存在的问题和不足很快就会被人发现，开源软件提供者会很快的修正或扩展这些技术，因此版本更新很快，几个星期或者几天就有一个新版本出来。 当我们在技术线路中选择了Java，也就选择了你必须持续学习，经常关注最新的技术，了解它们，看是否适合你的需要，然后学习使用它们。
IOC的思想是：Spring容器来实现这些相互依赖对象的创建、协调工作。对象只需要关系业务逻辑本身就可以了。从这方面来说，对象如何得到他的协作对象的责任被反转了（IOC、DI）。那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。
AOP的概念大家应该都知道吧，Aspect Oriented Programming的缩写，意为：面向切面编程（也叫面向方面），可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。
我们这样理解，AOP就是一个监控者，它在外面看着我们程序运行，同时也可以定一些规则，决定程序运行不运行，也可以在一个方法运行前进行处理，也可以在一个方法后进行一些逻辑处理。