Spring框架、Hibernate框架知识点
Spring里面的配置在applicationContext.xml中
1. IOC/DI，IOC（控制反转，Spring自己创建对象），DI（依赖注入，Sping中配置对象的属性）
XML配置方式：生成对象，注入对象、对象属性
<bean name="c" class="com.how2java.pojo.Category">//生成对象c
<property name="name" value="category 1" />//注入c的name属性
</bean>
<bean name="p" class="com.how2java.pojo.Product">//生成对象p
<property name="name" value="product1" />//注入p的name属性
<property name="category" ref="c" />//注入对象c
</bean>
注解方式（可以对 注入对象行为、bean对象本身注解）
（1）对注入对象行为的注解（Autowired，Resource）
1）
<context:annotation-config/> :告诉spring使用注解方式配置
<bean name="c" class="com.how2java.pojo.Category">
<property name="name" value="category 1" />
</bean>
<bean name="p" class="com.how2java.pojo.Product">
<property name="name" value="product1" />
<!-- <property name="category" ref="c" /> -->
</bean>
2）@Autowired（也可以在setCategory方法前加上@Autowired），@Resource
例如：在Product.java的category属性前加上@Autowired注解
或：@Resource(name="c")
private Category category;
（2）对Bean的注解
<context:component-scan base -package="com.how2java.pojo"/>：告诉Spring，bean都放在com.how2java.pojo这个包下
@Component
为Product类加上@Component注解，即表明此类是bean
@Component("p")
public class Product {
为Category 类加上@Component注解，即表明此类是bean
@Component("c")
public class Category {
另外，因为配置从applicationContext.xml中移出来了，所以属性初始化放在属性声明上进行了。
private String name="product 1";
private String name="category 1";
2. AOP
AOP
即 Aspect Oriented Program 面向切面编程
首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。
所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务
所谓的周边功能，比如性能统计，日志，事务管理等等
AOP专有名词：
target : 目标类
joinpoint : 连接点是指所有可能织入通知的方法,理论上大部分方法都是连接点
pointcut : 切入点, 匹配方法
advice: 通知,增强的方法,比如日志,事务
aspect : 切面,是指advice和pointcut的结合
weaving: 织入,将advice应用到目标对象来创建新的代理对象的过程
XML配置方式
<bean name="s" class="com.how2java.service.ProductService">
</bean>
<bean id="loggerAspect" class="com.how2java.aspect.LoggerAspect"/>
<aop:config>
<aop:pointcut id="loggerCutpoint"
expression=
"execution(* com.how2java.service.ProductService.*(..)) "/>
<aop:aspect id="logAspect" ref="loggerAspect">
<aop:around pointcut-ref="loggerCutpoint" method="log"/>
</aop:aspect>
</aop:config>
execution(*
com.how2java.service.ProductService.*(..))这表示对满足如下条件的方法调用，进行切面操作：
* 返回任意类型
com.how2java.service.ProductService.*包名以 com.how2java.service.ProductService 开头的类的任意方法
(..) 参数是任意数量和类型
注解方式
注解配置业务类 使用@Component("s") 注解ProductService 类
注解配置切面
@Aspect 注解表示这是一个切面
@Component 表示这是一个bean,由Spring进行管理
@Around(value = "execution(*
com.how2java.service.ProductService.*(..))") 表示对com.how2java.service.ProductService
这个类中的所有方法进行切面操作
@Aspect
@Component
public class LoggerAspect {
@Around(value = "execution(* com.how2java.service.ProductService.*(..))")
public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("start log:" + joinPoint.getSignature().getName());
Object object = joinPoint.proceed();
System.out.println("end log:" + joinPoint.getSignature().getName());
return object;
}
}
applicationContext.xml
<context:component-scan base-package="com.how2java.aspect"/>
<context:component-scan base-package="com.how2java.service"/>
<aop:aspectj-autoproxy/> 找到被注解了的切面类，进行切面配置
3. Spring注解方式测试
@RunWith(SpringJUnit4ClassRunner.class) //表示这是一个Spring的测试类
@ContextConfiguration("classpath:applicationContext.xml") //定位Spring的配置文件
public class TestSpring {
@Autowired //给这个测试类装配Category对象
Category c;
@Test //测试逻辑，打印c对象的名称
public void test(){
System.out.println(c.getName());
}
}
Spring MVC(使用Eclipse创建的web项目)
1.
在WEB-INF目录下创建 web.xml
配置Spring MVC的入口 DispatcherServlet，把所有的请求都提交到该Servlet
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
2. 在WEB-INF目录下创建 springmvc-servlet.xml
这是Spring MVC的 映射配置文件
表示访问路径/index会交给id=indexController的bean处理
id=indexController的bean配置为类：IndexController
<beans>
<bean id="simpleUrlHandlerMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
<prop key="/index">indexController</prop>
</props>
</property>
</bean>
<bean id="indexController" class="controller.IndexController"></bean>
</beans>
3. 控制类 IndexController
控制类
IndexController实现接口Controller ，提供方法handleRequest处理请求
SpringMVC通过 ModelAndView 对象把模型和视图结合在一起
ModelAndView mav = new ModelAndView("index.jsp");
mav.addObject("message", "Hello Spring MVC");
表示视图是index.jsp
模型数据是 message，内容是 “Hello Spring
MVC”
public class IndexController implements Controller {
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
ModelAndView mav = new ModelAndView("index.jsp");
mav.addObject("message", "Hello Spring MVC");
return mav;
}
}
4.准备index.jsp
在WebContent目录下创建index.jsp
index.jsp很简单，通过EL表达式显示message的内容
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" isELIgnored="false"%>
<h1>${message}</h1>
5. 部署在tomcat中，重启测试
部署在Tomcat中，重启tomcat，然后访问地址，观察效果
http://127.0.0.1:8080/springmvc/index
总结
原理图
1. 用户访问 /index
2. 根据web.xml中的配置 所有的访问都会经过DispatcherServlet
3. 根据 根据配置文件springmvc-servlet.xml ，访问路径/index
会进入IndexController类
4. 在IndexController中指定跳转到页面index.jsp，并传递message数据
5. 在index.jsp中显示message信息
SpringMVC运行原理
客户端请求提交到DispatcherServlet
由DispatcherServlet控制器查询HandlerMapping，找到并分发到指定的Controller中。
Controller调用业务逻辑处理后，返回ModelAndView
DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图
视图负责将结果显示到客户端
注：使用注解方式进行跳转
修改IndexController
在类前面加上@Controller 表示该类是一个控制器
在方法handleRequest 前面加上 @RequestMapping("/index") 表示路径/index会映射到该方法上
注意：不再让IndexController实现Controller接口
修改springmvc-servlet.xml
去掉映射相关的配置，因为已经使用注解方式了
增加<context:component-scan
base-package="controller" />
表示从包controller下扫描有@Controller注解的类
Hibernate
1. 创建实体类POJO（以下用Product实体类作为例子）
2. 配置 Product.hbm.xml（文件名P要大写，和类保持一致）
<hibernate-mapping package="com.how2java.pojo"> //实体类所在位置
<class name="Product" table="product_">//实体类和表映射
<id name="id" column="id">//实体属性id，映射表中id字段
<generator class="native">//id的自增长方式采用数据库的本地方式
</generator>
</id>
<property name="name" />//只写了属性name，省略了column=“name”
<property name="price" />
</class>
</hibernate-mapping>
3. 配置 hibernate.cfg.xml
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="connection.url">jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8</property>
<property name="connection.username">root</property>
<property name="connection.password">admin</property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>//使用mysql
<property name="current_session_context_class">thread</property>//事务管理方式，一个线程一个事务
<property name="show_sql">true</property>//是否在控制台显示hibernate生成的sql语句
<property name="hbm2ddl.auto">update</property>//是否会自动更新数据库的表结构，有这句话不需要创建表，因为hibernate会自动去创建表结构
<mapping resource="com/how2java/pojo/Product.hbm.xml" />//表示hibernate会去识别Product这个类
</session-factory>
</hibernate-configuration>
4.创建一个对象，并通过hibernate把这个对象，插入到数据库中
hibernate的基本步骤是：
1. 获取SessionFactory
2. 通过SessionFactory 获取一个Session
3. 在Session基础上开启一个事务
4. 通过调用Session的save方法把对象保存到数据库
5. 提交事务
6. 关闭Session
7. 关闭SessionFactory
基本原理图
应用程序通过Hibernate把 一个 Product对象插入到数据库的product_表中
hibernate.cfg.xml
配置文件提供链接数据库的基本信息
账号 密码 驱动 数据库ip 端口
Product.hbm.xml 提供对象与表的映射关系
对应哪个表？ 什么属性，对应什么字段
hibernate理论知识点
1. 对象状态
实体类对象在Hibernate中有3种状态
分别是瞬时，持久和脱管
瞬时 指的是没有和hibernate发生任何关系，在数据库中也没有对应的记录，一旦JVM结束，这个对象也就消失了
持久 指得是一个对象和hibernate发生联系，有对应的session,并且在数据库中有对应的一条记录
脱管 指的是一个对象虽然在数据库中有对应的一条记录，但是它所对应的session已经关闭了
例如：
new 了一个Product();，在数据库中还没有对应的记录，这个时候Product对象的状态是瞬时的。
通过Session的save把该对象保存在了数据库中，该对象也和Session之间产生了联系，此时状态是持久的。
最后把Session关闭了，这个对象在数据库中虽然有对应的数据，但是已经和Session失去了联系，相当于脱离了管理，状态就是脱管的
2. 查询：hql，criteria，标准sql
使用HQL,根据name进行模糊查询
1. 首先根据hql创建一个Query对象
2. 设置参数(和基1的PreparedStatement不一样，Query是基0的)
3. 通过Query对象的list()方法即返回查询的结果了。
注：使用hql的时候，用的是类名Product,而不是表名product_
注：使用hql的时候，不需要在前面加 select *
String name = "iphone";
Query q =s.createQuery("from Product p where p.name like ?");（s是session对象）
q.setString(0, "%"+name+"%");
List<Product> ps= q.list();
for (Product p : ps) {
System.out.println(p.getName());
}
使用Criteria,根据name进行模糊查询
使用Criteria
查询数据
1. 通过session的createCriteria创建一个Criteria 对象
2. Criteria.add 增加约束。 在本例中增加一个对name的模糊查询(like)
3. 调用list()方法返回查询结果的集合
除此之外，Criteria 还可以很方便的进行进行分页查询和获取总数
String name = "iphone";
Criteria c= s.createCriteria(Product.class);
c.add(Restrictions.like("name", "%"+name+"%"));
List<Product> ps = c.list();
for (Product p : ps) {
System.out.println(p.getName());
}
Hibernate使用Criteria 来进行分页查询
c.setFirstResult(2); 表示从第2条数据开始
c.setMaxResults(5); 表示一共查询5条数据
使用标准SQL,根据name进行模糊查询
使用Session的createSQLQuery方法执行标准SQL语句
因为标准SQL语句有可能返回各种各样的结果，比如多表查询，分组统计结果等等。 不能保证其查询结果能够装进一个Product对象中，所以返回的集合里的每一个元素是一个对象数组。 然后再通过下标把这个对象数组中的数据取出来。
String name = "iphone";
String sql = "select * from product_ p where p.name like '%"+name+"%'";
Query q= s.createSQLQuery(sql);
List<Object[]> list= q.list();
for (Object[] os : list) {
for (Object filed: os) {
System.out.print(filed+"\t");
}
System.out.println();
}
3. 延迟加载(分为属性、关系)
属性的延迟加载: （hibernate配置中有个显示sql的选项，打开之后每次事务提交都会显示SQL语句，可以用这个来判断是否加载了对象）
当使用load的方式来获取对象的时候，只有访问了这个对象的属性，hibernate才会到数据库中进行查询。否则不会访问数据库
关系延迟加载： one-many many-many的时候可以使用
作用：比如有的页面只需要显示分类信息，这个时候倘若没有开启延迟加载，那么就会把分类下的产品也查询出来了，增加了不必要的开销
4. 缓存
缓存是存储hibernate从数据库中查询的对象（因为每次查询都会生成sql语句，所以可以通过重复查询来看是否生成sql语句，来判断是否缓存成功）
hibernate默认是开启一级缓存的，一级缓存存放在session上，二级缓存是在SessionFactory上
5. 获取对象的方式
通过id获取Product对象有两种方式，分别是get和load
他们的区别分别在于
1. 延迟加载
load方式是延迟加载，只有属性被访问的时候才会调用sql语句
get方式是非延迟加载，无论后面的代码是否会访问到属性，马上执行sql语句
2. 对于id不存在的时候的处理
get方式会返回null
load方式会抛出异常
6. hibernate获取session两种方式
openSession和getCurrentSession
他们的区别在于
1. 获取的是否是同一个session对象
openSession每次都会得到一个新的Session对象
getCurrentSession在同一个线程中，每次都是获取相同的Session对象，但是在不同的线程中获取的是不同的Session对象
2. 事务提交的必要性
openSession只有在增加，删除，修改的时候需要事务，查询时不需要的
getCurrentSession是所有操作都必须放在事务中进行，并且提交事务后，session就自动关闭，不能够再进行关闭
7. query的list（）和iterator的区别
1.返回的类型不一样，list返回List，iterate返回iterator.
2.查询策略不同。(获取数据的方式不一样,list会直接查询数据库,iterate会先到数据库中获取id,然后真正遍历某个对象引用的时候,先到缓存中找,如果找不到，以id为条件再发一条sql到数据库，这样如果缓存中没有数据，则查询数据库的次数为n+1).
3.list中返回的list中每个对象都是其本身的对象，iterate中返回的对象是代理对象.
4.list只能put不能获取,iterate可以进行获取.
