053天
行百里者半九十，想要在一个行业里成为顶尖人才，一定满足一万小时定律，要想学好JAVA，需要持之以恒不断地努力,每天都要勤思考+善于询问+解决问题!
知识温故而知新>>>>>>
今天学到的知识>>>>>>
Spring整合MyBatis开发步骤，并描述其配置详情
Spring+MyBatis+Servlet(SpringMVC)整合步骤
一、Spring整合MyBatis:
总体思路:DataSource--->SqlSessionFacotyBean---->DAO(Mapper)---->Service
1.新建web项目并添加spring和mybatis依赖的jar文件(不要忘记添加spring整合mybatis的jar文件:mybatis-spring-x.x.x.jar)
2.新建实体类(Admin)
public class Admin implements Serializable {
private int id;
private String uname;
private String pwd;
//省略的getter和setter方法
}
3.新建Mapper接口(AdminMapper)和映射文件(AdminMapper.xml)
a.AdminMapper接口
public interface AdminMapper {
//查询单个用户操作
public Admin selectOne(String uname,String pwd);
}
b.AdminMapper映射文件
4.新建Service接口和实现类
a.AdminService接口
public interface AdminService {
public Admin login(String uname,String pwd);
}
b.AdminServiceImpl类,实现了AdminService接口
public class AdminServiceImpl implements AdminService {
AdminMapper adminMapper;
@Override
public Admin login(String uname, String pwd) {
Admin admin = adminMapper.selectOne(uname,pwd);
return admin;
}
//setter方法:setter注入
public void setAdminMapper(AdminMapper adminMapper) {
this.adminMapper = adminMapper;
}
}
5.在src下(classpath:类路径)新建spring的配置文件:applicationContext.xml
a.配置数据源DataSource,指定连接的数据库
b.配置SqlSessionFactoryBean,并注入数据源,用于生产SqlSession
c.配置扫描Mapper接口,作用是根据Mapper接口和映射文件生成实现类(类似与DAO的实现类)
d.配置Service的实现类，并注入Mapper对象
6.编写测试类
public class Test {
public static void main(String[] args) throws Exception {
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
AdminService adminService = ac.getBean("adminService", AdminService.class);
Admin admin = adminService.login("zhangsan","123");
System.out.println(admin);
}
}
二、Spring整合Servlet
1.在web.xml中配置初始化的参数app,用于指定spring配置文件的名称
app
applicationContext.xml
2.编写jsp页面login.jsp和success.jsp
a.login.jsp
用户登陆
b.success.jsp
用户登陆成功!
3.编写Servlet，读取spring配置文件获取service对象
@WebServlet("/AdminLogin")
public class AdminLogin extends HttpServlet{
AdminService adminService;
//Servlet的初始化方法:初始化Spring容器，并获取service对象
@Override
public void init() throws ServletException {
//读取全局参数app对应的参数值:applicationContext.xml
String path = this.getServletContext().getInitParameter("app");
ApplicationContext app=new ClassPathXmlApplicationContext(path);
//获得业务层创建好的对象
adminService = app.getBean("adminService",AdminService.class);
}
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//[1]接受页面数据
String uname = req.getParameter("uname");
String pwd = req.getParameter("pwd");
//[2]数据处理
Admin admin = adminService.login(uname, pwd);
//[3]做出响应
if(admin!=null){
resp.sendRedirect(req.getContextPath()+"/success.jsp");
}else {
req.setAttribute("msg","登陆失败");
req.getRequestDispatcher("/login.jsp").forward(req,resp);
}
}
}
AOP的相关概念
1.连接点（Joinpoint）
程序执行的某个特定位置：如类开始初始化之前、类初始化之后、类某个方法调用前、调用后等；一个类或一段程序代码拥有一些具有边界性质的特定点，这些代码中的特定点就成为“连接点”，Spring仅支持方法的连接点，即仅能在方法调用前、方法调用后以及方法调用前后的这些程序执行点织入增强。比如：黑客攻击系统需要找到突破口，没有突破口就没有办法攻击，从某种程度上来说，AOP就是一个黑客，连接点就是AOP向目标类攻击的候选点。连接点有两个信息确定：第一是用方法表示的程序执行点；第二是用相对点表示的方位；如在Test.foo()方法执行前的连接点，执行点为Test.foo，方位为该方法执行前的位置。Spring使用切点对执行点进行定位，而方位则在增强类型中定义。
2.切点（Pointcut）
每个程序类都拥有许多连接点，如一个拥有两个方法的类，这两个方法都是连接点，即连接点是程序类中客观存在的事物。但在为数众多的连接点中，如何定位到某个连接点上呢？AOP通过切点定位特定连接点。通过数据库查询的概念来理解切点和连接点：连接点相当于数据库表中的记录，而切点相当于查询条件。连接点和切点不是一一对应的关系，一个切点可以匹配多个连接点。
在Spring中，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件，Spring AOP的规则解析引擎负责解析切点所设定的查询条件，找到对应的连接点；其实确切的说应该是执行点而非连接点，因为连接点是方法执行前、执行后等包括方位信息的具体程序执行点，而切点只定位到某个方法上，所以如果希望定位到具体连接点上，还需要提供方位信息。
3.增强（Advice）
增强是织入到目标类连接点上的一段程序代码（好比AOP以黑客的身份往业务类中装入木马），增强还拥有一个和连接点相关的信息，这便是执行点的方位。结合执行点方位信息和切点信息，我们就可以找到特定的连接点了，所以Spring提供的增强接口都是带方位名的：BefortAdvice、AfterReturningAdvice、ThrowsAdvice等。（有些将Advice翻译为通知，但通知就是把某个消息传达给被通知者，并没有为被通知者做任何事情，而Spring的Advice必须嵌入到某个类的连接点上，并完成了一段附加的应用逻辑；）
4.目标对象（Target）
增强逻辑的织入目标类，如果没有AOP，目标业务类需要自己实现所有逻辑，在AOP的帮助下，目标类只实现那些非横切逻辑的程序逻辑，而其他监测代码则可以使用AOP动态织入到特定的连接点上。
5.引介（Introduction）
引介是一种特殊的增强，它为类添加一些属性和方法，这样即使一个业务类原本没有实现某个接口，通过AOP的引介功能，我们可以动态的为该业务类添加接口的实现逻辑，让这个业务类成为这个接口的实现类。
6.织入（Weaving）
织入是将增强添加到目标类具体连接点上的过程，AOP就像一台织布机，将目标类、增强或者引介编织到一起，AOP有三种织入的方式：
a.编译期间织入，这要求使用特殊的java编译器；
b.类装载期织入，这要求使用特殊的类装载器；
c.动态代理织入，在运行期为目标类添加增强生成子类的方式。
Spring采用动态代理织入，而AspectJ采用编译器织入和类装载期织入。
7.代理（Proxy）
一个类被AOP织入增强后，就产生出了一个结果类，它是融合了原类和增强逻辑的代理类。
8.切面（Aspect）
切面由切点和增强组成，它既包括了横切逻辑的定义，也包括了连接点的定义，Spring AOP就是负责实施切面的框架，它将切面所定义的横切逻辑织入到切面所指定的连接点中。
总结：AOP的工作重点就是如何将增强应用于目标对象的连接点上，这里首先包括两个工作：第一，如何通过切点和增强定位到连接点；第二，如何在增强中编写切面的代码。
代理的概念
代理模式是常用的java设计模式，他的特征是代理类与委托类(或目标类)有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
按照代理的创建时期，代理类可以分为两种。
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成，无需手动编写代码。动态代理不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java反射机制可以生成任意类型的动态代理类。
代理原理：代理对象内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
JDK动态代理
a. JDK动态代理是面向接口的，必须提供一个委托类和代理类都要实现的接口，只有接口中的方法才能够被代理。
b. JDK动态代理的实现主要使用java.lang.reflect包里的Proxy类和InvocationHandler接口。**
**InvocationHandler接口：**
来看看java的API帮助文档是怎么样描述InvocationHandler接口的：
Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.CLIMB动态代理
CGLib采用非常底层的字节码技术，可以为一个类创建一个子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，并顺势植入横切逻辑。
字节码生成技术实现AOP，其实就是继承被代理对象，然后Override需要被代理的方法，在覆盖该方法时，自然是可以插入我们自己的代码的。因为需要Override被代理对象的方法，所以自然用CGLIB技术实现AOP时，就必须要求需要被代理的方法不能是final方法，因为final方法不能被子类覆盖。
a.使用CGLIB动态代理不要求必须有接口，生成的代理对象是目标对象的子类对象，**所以需要代理的方法不能是private或者final或者static的。**
b.使用CGLIB动态代理需要有对cglib的jar包依赖（导入asm.jar和cglib-nodep-2.1_3.jar）
CGLibProxy与JDKProxy的代理机制基本类似，只是其动态代理的代理对象并非某个接口的实现，而是针对目标类扩展的子类。换句话说JDKProxy返回动态代理类，是目标类所实现接口的另一个实现版本，它实现了对目标类的代理（如同UserDAOProxy与UserDAOImp的关系），而CGLibProxy返回的动态代理类，则是目标代理类的一个子类（代理类扩展了UserDaoImpl类）
**cglib 代理特点：**
CGLIB 是针对类来实现代理，它的原理是对指定的目标类生成一个子类，并覆盖其中方法。因为采用的是继承，**所以不能对 finall 类进行继承**。
我们使用CGLIB实现上面的例子：
代理的最终操作类：
public class CglibProxy implements MethodInterceptor{ //增强器，动态代码生成器
Enhancer enhancer = new Enhancer(); /** * 创建代理对象
* @param clazz
* @return 返回代理对象 */
public Object getProxy(Class clazz){ //设置父类，也就是被代理的类(目标类)
enhancer.setSuperclass(clazz); //设置回调（在调用父类方法时，回调this.intercept()）
enhancer.setCallback(this); //通过字节码技术动态创建子类实例(动态扩展了UserServiceImpl类)
return enhancer.create();
} /** * 拦截方法：在代理实例上拦截并处理目标方法的调用，返回结果
* obj:目标对象代理的实例;
* method:目标对象调用父类方法的method实例;
* args:调用父类方法传递参数;
* proxy:代理的方法去调用目标方法 */
public Object intercept(Object obj,Method method,Object[] args,MethodProxy proxy) throws Throwable{
System.out.println("--------测试intercept方法的四个参数的含义-----------");
System.out.println("obj:"+obj.getClass());
System.out.println("method:"+method.getName());
System.out.println("proxy:"+proxy.getSuperName()); if(args!=null&&args.length>0){ for(Object value : args){
System.out.println("args:"+value);
}
} //目标方法之前执行
System.out.println("do sth Before..."); //目标方法调用 //通过代理类实例调用父类的方法，即是目标业务类方法的调用
Object result = proxy.invokeSuper(obj, args); //目标方法之后执行
System.out.println("do sth After...\n"); return result;
}
}
测试类：
package com.spring.aop;
public class CglibProxyTest { public static void main(String[] args){
CglibProxy proxy=new CglibProxy(); //通过java.lang.reflect.Proxy的getProxy()动态生成目标业务类的子类，即是代理类，再由此得到代理实例 //通过动态生成子类的方式创建代理类
IUserService target=(IUserService)proxy.getProxy(UserServiceImpl.class);
target.addUser();
target.deleteUser();
}
}