spring jdbc 及代理模式

最新推荐文章于 2022-12-29 10:55:12 发布
最新推荐文章于 2022-12-29 10:55:12 发布
阅读量903 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010220089/article/details/50895964
版权

spring jdbc 及代理模式

 

共性问题：

         1.服务器启动报错，什么原因？

                   *jar包缺少、jar包冲突

                            1)先检查项目中是否缺少jar包引用

                            2) 服务器: 检查jar包有没有发布到服务器下；

                                     用户库jar包，需要手动发布到tomcat.(每次新建项目)

                            3)重新发布项目

 

                   *配置文件错误

                            (web.xml/ struts.xml /bean.xml /hibernate.xml / *.hbm.xml)

                            明确的提示

 

                   *端口占用

 

                   *webapps项目过多

                            当前项目没有问题，有可能是其他项目出错，这样启动也会报错！但这个错误不是当前错误报的，所以不影响当前项目运行.

 

                   注意：

                            一般开发中，一个tomcat下只有一个项目。

                  

         2.一般启动报错： ClassNotFoundException异常

                   少jar包。

 

         3.访问404，什么原因？

                   1）客户端路径写错，或跳转错误。

                   2）启动报错

                            Web项目中，启动后一定要看下，是否报错。

 

 

         4.点击某个功能报错。

                   后台代码错误：

                            à 找到页面，点击哪个操作，提交到哪个地址

                            --》后台在提交地址的第一行打断点

 

 

Spring提供了一站式解决方案：

         1） Spring Core  spring的核心功能： IOC容器, 解决对象创建及依赖关系

         2） Spring Web  Spring对web模块的支持。

                                                        -à 可以与struts整合,让struts的action创建交给spring

                                                   -à spring mvc模式

         3） Spring DAO  Spring 对jdbc操作的支持  【JdbcTemplate模板工具类】

         4） SpringORM  spring对orm的支持：

                                                        à 既可以与hibernate整合，【session】

                                                        à 也可以使用spring的对hibernate操作的封装

         5）Spring AOP  切面编程

         6）SpringEE   spring 对javaEE其他模块的支持

 

 

目标：

         1） 代理模式

                   静态代理

                  动态代理

                   Cglib代理

         2）手动实现AOP编程 【代理模式】

         3）AOP编程

                    * 注解方式实现

                    * XMl配置方式实现

         4） Spring DAO 

                   Spring对jdbc操作的支持

 

 

1. 代理模式

1.1 概述

 代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式；即通过代理访问目标对象。 这样好处： 可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。

举例：明星（邓紫棋）ß---经纪人<-------用户 

             目标           （代理）

 

 

代理模式的关键点：代理对象与目标对象。

 

 

1.2 静态代理

静态代理，

         1） 代理对象，要实现与目标对象一样的接口；

         2） 举例:

                            保存用户(模拟)

                                     Dao  ,  直接保存

                                     DaoProxy,给保存方法添加事务处理

 

 

 

 

 

 

总结静态代理：

         1）可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。

         2）缺点：

                   --》  因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。

                   --》  一旦接口增加方法，目标对象与代理对象都要维护。

 

解决：

         代理工厂？  可以使用动态代理。

 

 

1.3 动态代理

动态代理，

         1）代理对象，不需要实现接口；

         2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);

         3)  动态代理， JDK代理， 接口代理；

 

JDK中生成代理对象的API：

|-- Proxy

         staticObject newProxyInstance(

ClassLoader loader,       指定当前目标对象使用类加载器

 Class<?>[] interfaces,     目标对象实现的接口的类型

InvocationHandler h       事件处理器

) 

 

 

动态代理总结：

         代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！
         (class  $Proxy0 implements IuserDao)

 

 

 

思考：

         有一个目标对象，想要功能扩展，但目标对象没有实现接口，怎样功能扩展？

         Class  UserDao{}

         //子类的方式

         Classsubclass  extends  UserDao{}

                                               

         以子类的方式实现(cglib代理)

 

 

1.4 Cglib代理

Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。

 

l  JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。

l    CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

l   CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

 

 

Cglib子类代理：

         1)需要引入cglib – jar文件，但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。

         2）引入功能包后，就可以在内存中动态构建子类

         3）代理的类不能为final， 否则报错。

         4） 目标对象的方法如果为final/static,那么就不会被拦截，即不会执行目标对象额外的业务方法。

 

        

在Spring的AOP编程中，

         如果加入容器的目标对象有实现接口，用JDK代理；

         如果目标对象没有实现接口，用Cglib代理；

 

 

2. 手动实现AOP编程

AOP 面向切面的编程，

         AOP可以实现“业务代码”与“关注点代码”分离

 

// 保存一个用户

public void add(User user) {

                   Session session = null;

                   Transaction trans = null;

                   try {

                            session = HibernateSessionFactoryUtils.getSession();   // 【关注点代码】

                            trans = session.beginTransaction();    // 【关注点代码】

                             

                            session.save(user);     // 核心业务代码

                             

                            trans.commit();     //…【关注点代码】

 

                   } catch (Exception e) {     

                            e.printStackTrace();

                            if(trans != null){

                                     trans.rollback();   //..【关注点代码】

 

                            }

                   } finally{

                            HibernateSessionFactoryUtils.closeSession(session);   ..【关注点代码】

 

                   }

   }

 

 

分析总结：

         关注点代码，就是指重复执行的代码。

         业务代码与关注点代码分离，好处？

            --à 关注点代码写一次即可；

                   -à开发者只需要关注核心业务；

                   -à运行时期，执行核心业务代码时候动态植入关注点代码； 【代理】

 

 

如何分离？

         过程式/对象式/代理模式分离

 

 

 

3. AOP编程

3.1 概述：

Aop，  aspect objectprogramming  面向切面编程

         功能： 让关注点代码与业务代码分离！

关注点,

         重复代码就叫做关注点；

切面，

          关注点形成的类，就叫切面(类)！

          面向切面编程，就是指对很多功能都有的重复的代码抽取，再在运行的时候网业务方法上动态植入“切面类代码”。

切入点，

         执行目标对象方法，动态植入切面代码。

         可以通过切入点表达式，指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码。

 

3.2 注解方式实现AOP编程

步骤：

1） 先引入aop相关jar文件           （aspectj  aop优秀组件）                                      

         spring-aop-3.2.5.RELEASE.jar   【spring3.2源码】

aopalliance.jar                              【spring2.5源码/lib/aopalliance】

aspectjweaver.jar                        【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】

aspectjrt.jar                                   【spring2.5源码/lib/aspectj】或【aspectj-1.8.2\lib】

 

注意：用到spring2.5版本的jar文件，如果用jdk1.7可能会有问题。

                   需要升级aspectj组件，即使用aspectj-1.8.2版本中提供jar文件提供。

 

 

2） bean.xml中引入aop名称空间

 

 

3） 开启aop注解

 

4) 使用注解

@Aspect                                                              指定一个类为切面类             

@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")  指定切入点表达式

 

@Before("pointCut_()")                                  前置通知: 目标方法之前执行

@After("pointCut_()")                                               后置通知：目标方法之后执行（始终执行）

@AfterReturning("pointCut_()")                       返回后通知： 执行方法结束前执行(异常不执行)

@AfterThrowing("pointCut_()")                    异常通知:  出现异常时候执行

@Around("pointCut_()")                                 环绕通知： 环绕目标方法执行

 

 

1. IUserDao.java

// 接口

publicinterface IUserDao {

    void save();

}

 

2. UserDao.java

/**

 * 目标对象

 * @author Jie.Yuan

 *

 */

@Component   // 加入容器

publicclass UserDao implements IUserDao{

 

    @Override

    publicvoid save() {

        System.out.println("-----核心业务：保存！！！------");

    }

}

 

3. Aop.java  切面类

 

@Component

@Aspect  // 指定当前类为切面类

publicclass Aop {

 

    // 指定切入点表单式：拦截哪些方法；即为哪些类生成代理对象

   

    @Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")

    publicvoid pointCut_(){

    }

   

    // 前置通知 : 在执行目标方法之前执行

    @Before("pointCut_()")

    publicvoid begin(){

        System.out.println("开始事务/异常");

    }

   

    // 后置/最终通知：在执行目标方法之后执行  【无论是否出现异常最终都会执行】

    @After("pointCut_()")

    publicvoid after(){

        System.out.println("提交事务/关闭");

    }

   

    // 返回后通知：在调用目标方法结束后执行【出现异常不执行】

    @AfterReturning("pointCut_()")

    publicvoid afterReturning() {

        System.out.println("afterReturning()");

    }

   

    // 异常通知：当目标方法执行异常时候执行此关注点代码

    @AfterThrowing("pointCut_()")

    publicvoid afterThrowing(){

        System.out.println("afterThrowing()");

    }

   

    // 环绕通知：环绕目标方式执行

    @Around("pointCut_()")

    publicvoid around(ProceedingJoinPoint pjp) throws Throwable{

        System.out.println("环绕前....");

        pjp.proceed();  // 执行目标方法

        System.out.println("环绕后....");

    }

   

}

4. bean.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd">

   

    <!-- 开启注解扫描 -->

    <context:component-scan base-package="cn.itcast.e_aop_anno"></context:component-scan>

   

    <!-- 开启aop注解方式 -->

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>  

 

 

App.java

 

publicclass App {

   

    ApplicationContext ac =

        new ClassPathXmlApplicationContext("cn/itcast/e_aop_anno/bean.xml");

 

    // 目标对象有实现接口，spring会自动选择“JDK代理”

    @Test

    publicvoid testApp() {

        IUserDao userDao = (IUserDao) ac.getBean("userDao");

        System.out.println(userDao.getClass());

        userDao.save();

    }

   

    // 目标对象没有实现接口， spring会用“cglib代理”

    @Test

    publicvoid testCglib() {

        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");

        System.out.println(orderDao.getClass());

        orderDao.save();

    }

}

 

 

 

3.3 XML方式实现AOP编程

 

Xml实现aop编程：

         1） 引入jar文件  【aop 相关jar， 4个】

         2） 引入aop名称空间

         3）aop 配置

                   *配置切面类 （重复执行代码形成的类）

                   *aop配置

                            拦截哪些方法 / 拦截到方法后应用通知代码

 

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd">

   

    <!-- dao 实例 -->

    <bean id="userDao" class="cn.itcast.f_aop_xml.UserDao"></bean>

    <bean id="orderDao" class="cn.itcast.f_aop_xml.OrderDao"></bean>

   

    <!-- 切面类 -->

    <bean id="aop" class="cn.itcast.f_aop_xml.Aop"></bean>

   

    <!-- Aop配置 -->

    <aop:config>

        <!-- 定义一个切入点表达式：拦截哪些方法 -->

        <aop:pointcut expression="execution(* cn.itcast.f_aop_xml.*.*(..))" id="pt"/>

        <!-- 切面 -->

        <aop:aspect ref="aop">

            <!-- 环绕通知 -->

            <aop:around method="around" pointcut-ref="pt"/>

            <!-- 前置通知：在目标方法调用前执行 -->

            <aop:before method="begin" pointcut-ref="pt"/>

            <!-- 后置通知： -->

            <aop:after method="after" pointcut-ref="pt"/>

            <!-- 返回后通知 -->

            <aop:after-returning method="afterReturning" pointcut-ref="pt"/>

            <!-- 异常通知 -->

            <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>

           

        </aop:aspect>

    </aop:config>

</beans> 

 

3.4  切入点表达式

切入点表达式,

         可以对指定的“方法”进行拦截；  从而给指定的方法所在的类生层代理对象。

 

 

 

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:p="http://www.springframework.org/schema/p"

    xmlns:context="http://www.springframework.org/schema/context"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop.xsd">

   

    <!-- dao 实例 -->

    <bean id="userDao" class="cn.itcast.g_pointcut.UserDao"></bean>

    <bean id="orderDao" class="cn.itcast.g_pointcut.OrderDao"></bean>

   

    <!-- 切面类 -->

    <bean id="aop" class="cn.itcast.g_pointcut.Aop"></bean>

   

    <!-- Aop配置 -->

    <aop:config>

       

        <!-- 定义一个切入点表达式：拦截哪些方法 -->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.*.*(..))" id="pt"/>-->

       

        <!-- 【拦截所有public方法】 -->

        <!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->

       

        <!-- 【拦截所有save开头的方法】 -->

        <!--<aop:pointcut expression="execution(* save*(..))" id="pt"/>-->

       

        <!-- 【拦截指定类的指定方法, 拦截时候一定要定位到方法】 -->

        <!--<aop:pointcut expression="execution(public * cn.itcast.g_pointcut.OrderDao.save(..))" id="pt"/>-->

       

        <!-- 【拦截指定类的所有方法】 -->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.*(..))" id="pt"/>-->

       

        <!-- 【拦截指定包，以及其自包下所有类的所有方法】 -->

        <!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->

       

        <!-- 【多个表达式】 -->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) || execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) or execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

        <!-- 下面2个且关系的，没有意义 -->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) &amp;&amp; execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) and execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

       

        <!-- 【取非值】 -->

        <!--<aop:pointcut expression="!execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->

        <aop:pointcut expression=" not execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>

       

        <!-- 切面 -->

        <aop:aspect ref="aop">

            <!-- 环绕通知 -->

            <aop:around method="around" pointcut-ref="pt"/>

        </aop:aspect>

    </aop:config>

</beans>   

 

 

 

4. Spring对jdbc支持

 

使用步骤：

         1）引入jar文件

spring-jdbc-3.2.5.RELEASE.jar

spring-tx-3.2.5.RELEASE.jar

         2） 优化

 


大数据的未来
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring整合JDBC实现转账业务-动态代理模式
06-01
Spring整合JDBC实现转账业务-动态代理模式demo源代码,在这里我们我们对其Spring整合JDBC实现转账业务进行优化更新,使其业务层完全脱离我们的事务书写,我们采用的时候动态代理模式
JDBC介绍及入门实例和对Proxy的介绍
latherou的博客
09-11 151
JDBC 是一种 操作 数据库的 标准 和 规范 、只有标准 而没有具体的实现。
【深入浅出Spring6】第七期——使用JDBC模板与代理模式
欢迎来到我的世界
11-20 507
介绍了Spring内置的JDBC模板如何使用，也介绍了静态代理、JDK动态代理和CGLIB动态代理
Seata-AT模式数据源代理-JDBC中的关键知识点
BASK2312的博客
12-29 333
JDBC 代表 Java 数据库连接。JDBC 是一种 Java API，用于连接数据库并执行查询。它是 JavaSE（Java 标准版）的一部分。JDBC API 使用 JDBC 驱动程序连接数据库。在 JDBC 之前，ODBC API 是连接数据库并执行查询的数据库 API。但是，ODBC API 使用用 C 语言编写的 ODBC 驱动程序（即依赖于平台且不安全）。这就是为什么 Java 定义了自己的 API (JDBC API)，它使用 JDBC 驱动程序（用 Java 语言编写）。
JDBC动态代理归还连接
xiaoChenPengYou的博客
09-15 221
JDBC动态代理归还连接
jdbc------连接池代理
sujingnuli1的博客
01-13 825
代理： 动态代理模式： java中代理模式：动态/静态/Cglib代理（Spring） 接口，某个方法，扩展，不想实现所有方式 Connection ,close 扩展，不实现所有方法。 动态代理 监测，接口中，方法的执行。 close()方法，如何对Connection对象， 生成一个代理对象， ---proxy static Object newProxyInstance(
spring.doc
10-25
代理模式拓展： 52 4.1.1 JDK动态代理 58 JDK动态代理拓展： 59 4.1.2 CGLIB做代理 66 CGLIB动态代理拓展： 68 4.1.3 Spring的动态代理 71 4.2 AOP编程 71 4.2.1概念： 71 SpringAOP概念拓展： 73 之前实现了目标...
Spring高级之注解驱动开发视频教程
11-05
n 设计模式-代理模式 n 编程思想-AOP思想 n 基础应用-入门案例 n 基础应用-常用注解 n 高级应用-DeclareParents注解 n 高级应用-EnableLoadTimeWeaving n 源码分析-@EnableAspectJAutoproxy注解加载过程分析 n 源码...
spring security 参考手册中文版
02-01
5.6.2 JDBC认证 39 5.6.3 LDAP认证 39 5.6.4 AuthenticationProvider 41 5.6.5 UserDetailsService 41 5.6.6 LDAP认证 41 5.7多个HttpSecurity 41 5.8方法安全性 43 5.8.1 EnableGlobalMethodSecurity 43 5.8.2 ...
jdbc proxy 代理类
07-10
代码对应的blog http://blog.csdn.net/keyboardsun/archive/2008/01/30/2072865.aspx
数据库连接池——JDBC通过代理模式来保持用户关闭连接的习惯
05-25
NULL 博文链接：https://ccx20060810501.iteye.com/blog/480227
Spring AOP、代理、JDBC支持
guanhang89的专栏
09-22 714
代理模式代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式；即通过代理访问目标对象。 这样好处： 可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。 举例：明星（邓紫棋） —经纪人<——-用户 目标 （代理） 代理模式的关键点： 代理对象与目标对象。静态代理静态代理:1） 代理对象，要实现与目标对象一样的接口； 2）
spring的代理模式
weixin_43723296的博客
07-07 3567
1、何为代理模式 如何实现在不修改源码的基础上实现代码功能的增强呢？spring为我们提供了代理模式。所谓的代理模式通俗来说就是一个中介，它给某一个对象提供一个代理对象，并由代理对象控制原对象的引用，从而实现在不修改源码的基础上实现代码功能的增强。2、分类 按照代理创建的时期进行分类，可以分为两类：静态代理、动态代理。 静态代理的代理类=原始类+增强（额外功能）+和原始类实现同一个接口，即基于接口的代理。 动态代理又分为jdk动态代理，其也是基于接口的
AOP详解
北京叮咚的博客
05-18 6306
文章目录 目录 前言 二、设计模式 三、名词解释 四、代码 方式一 方式二 方式三：注解 总结 前言 Spring的两大核心是IOC和AOP，其中IOC是指控制反转，指的是bean对象无需用户手动维护，全部交由Spring管理；AOP大家都知道是面向切面，但是什么是面向切面，这里面由涉及的一些名词如何理解，我们如何理解并使用AOP，在这里我们简单聊一下 一、AOP是什么？ AOP（Aspect-Oriented Programming，面向方面编程），可以说是OOP...
Spring框架中的代理模式
YiGeiGiaoGiao的博客
11-21 949
代理模式
JDBC实战（六）数据源、连接池、代理模式、动态代理
LH is programming hard
08-07 801
文章目录连接池、代理模式、动态代理1、数据源和连接池1、创建基本的数据源类2、使用代理模式来保持因使用数据源连接池导致的用户关闭不习惯问题3、使用动态代理完善连接代理3.1、什么是动态代理3.2、使用动态代理来实现Proxy_MyConnection类 连接池、代理模式、动态代理 1、数据源和连接池 所谓数据源也就是数据的来源。它存储了所有建立数据库连接需要的信息。算是对数据库的一个抽象映射，即一个数据源对于一个数据库。 数据源有以下属性 databaseName String数据库名称，即数据库的SID
JDBC连接池&动态代理
qq_38353993的博客
10-09 1539
一 PreparedStatement 1.1 登录案例 上一篇博文中的最后的用户登录案例，使用Statement对象执行SQL语句会出现一个问题： 用户不输入密码，只输入用户名，一样可以登录成功 问题 SELECT * FROM USER WHERE username = 'admin ' #' and password = ''; -- 使用#号将后半段的密码验证消除，#号在mysql中是备注...
spring用到哪些设计模式
最新发布
11-16
3. 代理模式：Spring AOP（面向切面编程）就是基于代理模式实现的，它可以在不修改原有代码的情况下，为方法添加额外的功能。 4. 模板方法模式：Spring中的JdbcTemplate就是一个模板方法模式的实现，它封装了JDBC...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值