Spring（2）

最新推荐文章于 2024-10-01 13:49:09 发布
最新推荐文章于 2024-10-01 13:49:09 发布
阅读量366 收藏
点赞数
分类专栏： 框架 文章标签： spring 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/op134972/article/details/72803586
版权

Spring（2）

温故而知新！复习以前学过的框架知识，肯定会有新的收获。

Java中的代理分为静态代理和动态代理（JDK代理），和CGLIB代理。

动态代理

利用JDK中的Proxy类生成代理。因此成为JDK代理。

目标对象一定要实现接口, 代理对象不用实现接口。

/**
 * 动态代理：
 *    代理工厂，给多个目标对象生成代理对象！
 * @author Wch
 *
 */
public class ProxyFactory {

    // 接收一个目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }


    // 返回对目标对象(target)代理后的对象(proxy)
    public Object getProxyInstance() {
        Object proxy = Proxy.newProxyInstance(
                target.getClass().getClassLoader(),  // 目标对象使用的类加载器
                target.getClass().getInterfaces(),   // 目标对象实现的所有接口
                new InvocationHandler() {           // 执行代理对象方法时候触发
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {

                        // 获取当前执行的方法的方法名
                        String methodName = method.getName();
                        // 方法返回值
                        Object result = null;

                        // 判断
                        if ("find".equals(methodName)) {
                            // 直接调用目标对象方法
                            result = method.invoke(target, args);
                        } else {
                            System.out.println("开启事务...");
                            // 执行目标对象方法
                            result = method.invoke(target, args);
                            System.out.println("提交事务...");

                        }
                        return result;
                    }
                }
        );
        return proxy;
    }   
}

/**
 * 动态代理工厂类
 * @author Wch
 *
 */
class myProxyFactory{
    private Object target;

    public myProxyFactory(Object obj) {
        this.target = obj;
    }

    public Object getProxyObj(){
        Object proxyObj = Proxy.newProxyInstance(target.getClass().getClassLoader()
                            ,target.getClass().getInterfaces()
                            , new InvocationHandler() {

                                @Override
                                public Object invoke(Object proxy, Method method, Object[] args)
                                        throws Throwable {
                                    //对指定方法进行代理加强
                                    String name = method.getName();
                                    return method.invoke(target, args);
                                }
                            });
        return proxyObj;
    }   
}

Cglib代理

也叫”子类代理”，当目标对象没有实现接口，就不能使用jdk提供的代理，可以以子类的方式实现！
在运行时期动态在内存中构建一个子类对象的方法，从而对目标对象扩展，这种就是cglib代理！

在SpringAop编程中，
如果目标对象有实现接口，spring使用jdk提供的代理生成代理对象！
如果目标对象没有实现接口，使用cglib代理！
如果目标没有实现接口、且为final , 不能进行aop编程，报错！不能生成代理！

AOP编程

Aspect Oriented Programming

面向切面编程，分离业务代码和关注点代码，在业务代码中动态的植入关注点。

关注点：重复执行的代码，就称为关注点代码。

切面：关注点代码形成的类，就叫做切面。
enter image description here

个人理解：面向切面编程是为了提高代码的复用性，利用代理和反射在执行目标代码之前或之后执行切面代码。分离了业务代码和关注点代码，使得用户能够更好的关注逻辑代码的编写和更好的进行分离维护。

举例说明哪些是切面？
事务、权限控制、日志等

切入点表达式：拦截方法，给方法所在的类，生成代理对象（若类实现了接口：$proxyXXX；继承：cglib代理对象）

Spring在初始化容器的时候，会根据切入点表达式的规则，对复合拦截规则的类生成代理对象。

reference：
http://blog.csdn.net/Intlgj/article/details/5671248

使用注解实现AOP编程的步骤

  1. 引入aop 相关 jar文件
    (aspectj 是在spring之前，面向切面开发的公用组件)
    aopalliance.jar 【spring-framework-2.5.6\lib\aopalliance】
    aspectjrt.jar 【spring-framework-2.5.6\lib\aspectj】
    aspectjweaver.jar 【spring-framework-2.5.6\lib\aspectj】
    spring-aop-3.2.5.RELEASE.jar 【Spring3.2源码】

  2. 引入aop名称空间

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    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.ustb.e_aop_anno"></context:component-scan>
    <!-- 开启aop注解 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

  1. 开启aop注解
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

  2. 使用注解实现AOP编程

/*
@Aspect      指定一个类为切面类
                （切面类也需要实例化）
                （切面类中的方法，也叫做通知）
@Before        前置通知  【在执行目标对象方法之前执行】
@After             后置通知  【在执行目标对象方法之后执行】
@AfterReturning    返回后通知  【在执行目标对象方法结束后执行， 出现异常不执行】
@AfterThrowing    异常通知   【在执行目标对象方法出现异常时候执行】
@Around          环绕通知   【环绕目标方法执行】

@Pointcut      定义一个切入点表达式变量  （后面使用这个切入点表达式的时候，直接引用方法名即可）
*/
// 重复代码
@Component("aop")
@Aspect      // 指定一个类为切面类
public class TransactionAop {

    // 定义一个切入点表达式变量  （后面使用这个切入点表达式的时候，直接引用方法名即可）
    @Pointcut("execution(* cn.ustb.e_aop_anno.UserDao.*(..))")//表示拦截userDao的所有方法呀
    public void pointcut_(){
    }

    //【前置通知】
    // 在执行业务方法，之前执行
    @Before("pointcut_()")
    public void beginTransaction() {
        System.out.println("[前置通知]  开启事务..");
    }

    //【后置通知】
    // 在执行业务方法，之后执行
    @After("pointcut_()")
    public void commit() {
        System.out.println("[后置通知] 提交事务..");
    }

    // 【返回后通知】   在执行目标方法结束后执行, 出现异常不会执行
    @AfterReturning("pointcut_()")
    public void afterReturing(){
        System.out.println("[返回后通知]");
    }

    // 【异常通知】   在执行目标方法的时候出现异常执行
    @AfterThrowing("pointcut_()")
    public void afterThrowing(){
        System.out.println("[异常通知]");
    }

    // 【环绕通知】 会环绕目标方法执行
    @Around("pointcut_()")
    public void arroud(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("[环绕前：]");
        pjp.proceed();                 // 执行目标方法
        System.out.println("[环绕后：]");
    }

}
  1. 测试方法：

public class App {

     private ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml",getClass());

     // jdk代理
    @Test
    public void testApp() throws Exception {
        // springIOC容器中获取对象，用接口接收！
        IUserDao userDao = (IUserDao) ac.getBean("userDao");
        System.out.println(userDao.getClass());
        userDao.save();


        // springIOC容器中获取对象，用实现接收？   报错！！！！！！！！！
        /*
         *  java.lang.ClassCastException: 
         *      $Proxy13 cannot be cast to cn.ustb.e_aop_anno.UserDao
         */
        // 总结：在spring的aop编程中，符合切入点表达式的目标类，  如果目标对象有实现接口，从容器获取对象的时候，一定要通过接口接收！
        // 否则，包类型转换错误！
//      UserDao userDao = (UserDao) ac.getBean("userDao");
//      System.out.println(userDao.getClass());
//      userDao.save();
    }

    // cglib代理
    @Test
    public void testApp_cglib() throws Exception {
        UserDao userDao = (UserDao) ac.getBean("userDao");
        System.out.println(userDao.getClass());
        userDao.save();
    }

    // 没有生成代理对象，因为没有被切入点表达式拦截
    // execution(* cn.ustb.e_aop_anno.UserDao.*(..))
    @Test
    public void testApp_save_order() throws Exception {
        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
        System.out.println(orderDao.getClass());
        orderDao.save();
    }
}
使用XML配置实现AOP编程
  1. 导包（4个包），同注解方式一样
  2. 配置XML，注意几个重要的节点参数。<aop:config>、<aop:pointcut>、<aop:aspect>以及要声明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: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.ustb.f_aop_xml.UserDao"></bean>

    <!-- 实例化切面类 -->
    <bean id="aop111" class="cn.ustb.f_aop_xml.TransactionAop"></bean>

    <!-- Aop相关配置 -->
    <aop:config>
        <!-- 切入点表达式定义 -->
        <!-- *表示拦截了UserDao中的所有方法了 -->
        <aop:pointcut expression="execution(* cn.ustb.f_aop_xml.UserDao.*(..))" id="pt"/>

        <!-- 切面配置 -->
        <aop:aspect ref="aop111">

            <!-- 【环绕通知】 -->
            <aop:around method="arroud" pointcut-ref="pt"/>

            <!-- 【前置通知】 在目标方法之前执行 -->
            <aop:before method="beginTransaction" pointcut-ref="pt" />

            <!-- 【后置通知】 -->
            <aop:after method="commit" pointcut-ref="pt"/>

            <!-- 【返回后通知】 -->
            <aop:after-returning method="afterReturing" pointcut-ref="pt"/>

            <!-- 异常通知 -->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>


        </aop:aspect>
    </aop:config>

</beans>
  1. 定义切面类，定义通知（方法）
// 切面类
public class TransactionAop {

    public void beginTransaction() {
        System.out.println("[前置通知]  开启事务..");
    }

    public void commit() {
        System.out.println("[后置通知] 提交事务..");
    }

    public void afterReturing(){
        System.out.println("[返回后通知]");
    }

    public void afterThrowing(){
        System.out.println("[异常通知]");
    }

    public void arroud(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("[环绕前：]");
        pjp.proceed();                 // 执行目标方法
        System.out.println("[环绕后：]");
    }

}
  1. 测试
// 切面类
public class TransactionAop {

    public void beginTransaction() {
        System.out.println("[前置通知]  开启事务..");
    }

    public void commit() {
        System.out.println("[后置通知] 提交事务..");
    }

    public void afterReturing(){
        System.out.println("[返回后通知]");
    }

    public void afterThrowing(){
        System.out.println("[异常通知]");
    }

    public void arroud(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("[环绕前：]");
        pjp.proceed();                 // 执行目标方法
        System.out.println("[环绕后：]");
    }

}
Spring生成代理对象的过程？
  1. 创建容器对象的时候， 根据“切入点表达式”拦截的类，生成代理对象；（在创建容器的时候就生成了代理对象了）
  2. 如果目标对象有实现接口，使用jdk代理！
  3. 如果目标对象没有实现接口，使用cglib代理！
  4. 从容器获取代理后的对象
  5. 执行代理对象的方法，在运行时期，动态植入“切面”类中的“通知”!
切入点表达式语法详解

切入点表达式：
拦截指定的类，生成代理对象！

execution(
modifiers-pattern? ————–拦截的方法的访问修饰符
ret-type-pattern ————–方法返回类型，必须指定
declaring-type-pattern? ————–拦截的方法所在的类
name-pattern(param-pattern)————–拦截的方法（以及方法的参数列表）
throws-pattern?————– 方法声明的异常
)
示例：
execution(* cn.ustb.f_aop_xml.UserDao.*(..))
execution(* cn.ustb.e_aop_anno.UserDao.*(..))

<!-- 开启注解扫描 -->
<context:component-scan base-package="cn.ustb.g_execution"></context:component-scan>

<!-- dao实例加入容器 -->
<bean id="userDao" class="cn.ustb.g_execution.UserDao"></bean>

<!-- 实例化切面类 -->
<bean id="aop" class="cn.ustb.g_execution.TransactionAop"></bean>

<!-- Aop相关配置 -->
<aop:config>
    <!-- 切入点表达式定义 -->

    <!-- 1. 拦截指定的方法(通用)  -->
    <!--<aop:pointcut expression="execution(* cn.ustb.g_execution.UserDao.save(..))" id="pt"/>-->

    <!-- 2. 拦截指定的类下所有的方法 -->
    <!--<aop:pointcut expression="execution(* cn.ustb.g_execution.UserDao.*(..))" id="pt"/>-->

    <!-- 3. 拦截指定包下所有的类的所有方法 -->
    <!--<aop:pointcut expression="execution(* cn.ustb.g_execution.*.*(..))" id="pt"/>-->

    <!-- 3. 拦截指定包，以及其子包下所有类的所有方法 -->
    <!----><aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>

    <!-- 5. 拦截所有的public方法 -->
    <!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->

    <!-- 6. 拦截所有的包含save方法 -->
    <!--<aop:pointcut expression="execution(* *save*(..))" id="pt"/>-->

    <!-- 7. 拦截UserDao.save()方法与OrderDao.save() -->
    <!--<aop:pointcut expression="execution(* cn..UserDao.save(..)) || execution(* cn..OrderDao.save(..))" id="pt"/>-->
    <!--<aop:pointcut expression="execution(* cn..UserDao.save(..)) or execution(* cn..OrderDao.save(..))" id="pt"/>-->

    <!-- 8. 不拦截UserDao.save()方法 -->
    <!--<aop:pointcut expression="!execution(* cn..UserDao.save(..))" id="pt"/>-->
    <!--<aop:pointcut expression=" not execution(* cn..UserDao.save(..))" id="pt"/>-->

    <!-- 9. 拦截UserDao.save()同时拦截OrderDao.save() -->
    <!-- 注意： 这种很少用，一般都是或者的关系即: || 、 or  -->
    <!--<aop:pointcut expression="execution(* cn..UserDao.save(..)) and execution(* cn..OrderDao.save(..))" id="pt"/>-->
<!--        <aop:pointcut expression="execution(* cn..UserDao.save(..)) &amp;&amp; execution(* cn..OrderDao.save(..))" id="pt"/>
-->     


    <!-- 切面配置 -->
    <aop:aspect ref="aop">
        <aop:around method="arroud" pointcut-ref="pt"/>
    </aop:aspect>
</aop:config>

总结：
拦截，一定要指定到方法！

Spring 对jdbc模块的支持

到目前为止学习了Spring的功能有：
Spring Core ioc容器
Spring Web 对web支持（与struts整合）
Spring Aop 面向切面编程
Spring Jdbc 对jdbc的支持

Spring对JDBC的操作进行了简化，提供了JdbcTemplate模板工具类，简化Jdbc的操作！

import org.springframework.jdbc.core.JdbcTemplate;封装了Jdbc操作，将其当成Jdbc中的statement对象进行数据库的操作。

步骤
导包
  1. 导入对Jdbc支持的jar包
    spring-jdbc-3.2.5.RELEASE.jar 工具类包
    spring-tx-3.2.5.RELEASE.jar 事务支持依赖包
    c3p0-0.9.1.2.jar 连接池包
    mysql-connector-java-5.1.12-bin.jar 数据库驱动包
配置
  1. 加载db.properties配置，创建database的bean，创建JdbcTemplate的bean将其注入。
<!-- 加载Proerties配置文件 -->
<context:property-placeholder location="classpath:cn/ustb/h_jdbc/db.properties"/>
<bean id="propertyConfigure" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations">
        <list>
            <value>classpath:cn/ustb/h_jdbc/db.properties</value>
        </list>
    </property>
</bean>
<!-- 1.  实例化连接池  -->
<!-- 利用${}可以取出db.properties中的数据 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${driverClass}"></property>
    <property name="jdbcUrl" value="${jdbcUrl}"></property>
    <property name="user" value="${user}"></property>
    <property name="password" value="${password}"></property>
    <property name="initialPoolSize" value="${initialPoolSize}"></property>
    <property name="maxPoolSize" value="${maxPoolSize}"></property>
    <property name="acquireIncrement" value="${acquireIncrement}"></property>
</bean>

<!--  2. 创建JdbcTemplate对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>


<!-- 实例化dao -->
<bean id="deptDao" class="cn.ustb.h_jdbc.DeptDao">
    <property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>

db.properties

driverClass=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql:///hib_demo
user=root
password=root
initialPoolSize=3
maxPoolSize=6
acquireIncrement=2
编写CRUD代码
  1. 在Java代码中通过JdbcTemplate对象对数据库进行CRUD操作。
public class DeptDao implements IDeptDao {

    // 接收容器注入的JdbcTemplate对象
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }


    // 1. 原始jdbc代码
    public void save(Dept dept) {
        jdbcTemplate.update("insert into t_dept(deptName) values(?)", dept.getName());
    }


    @Override
    public void delete(Serializable id) {
        jdbcTemplate.update("delete from t_dept where id=?", id);
    }

    @Override
    public void update(Dept dept) {
        jdbcTemplate.update("update t_dept set deptName=? where id=?", dept.getName(),dept.getId());
    }


    @Override
    public Dept findById(Serializable id) {
        // queryForList 把每一行都封装为map对象，再添加到list中
//      List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from t_dept");

        // 传入类型参数，表示查询的列的类型；  这里只能查询一列
//      List<String> list = jdbcTemplate.queryForList("select deptName from t_dept", String.class);

         List<Dept> list = jdbcTemplate.query("select * from t_dept where id=?",  new MyRowMapper(), id);

        return (list!=null&&list.size()>0)?list.get(0):null;
    }

    @Override
    public List<Dept> getAll() {
        List<Dept> list = jdbcTemplate.query("select * from t_dept", new MyRowMapper());
        return list;
    }   

    // 封装Springjdbc查询的结果集
    class MyRowMapper implements RowMapper<Dept>{

        // 如何解析一行
        @Override
        public Dept mapRow(ResultSet rs, int rowNum) throws SQLException {
            Dept dept = new Dept();
            dept.setId(rs.getInt("id"));
            dept.setName(rs.getString("deptName"));
            return dept;
        }   
    }
    class MyRowMapo implements RowMapper<Dept>{

        @Override
        /**
         * 如何解析一行
         */
        public Dept mapRow(ResultSet rs, int rowNum) throws SQLException {
            Dept a = new Dept();
            a.setName(rs.getString("name"));
            a.setId(rs.getInt("id"));
            return a;
        }   
    }   
}
JdbcTemplate的API

见上面的代码，大部分的API已经囊括在内了。

reference：
http://blog.csdn.net/u011637069/article/details/50838630

kkkkkkkko223
关注
专栏目录
spring security原理和机制 | Spring Boot 35
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6。 此外，还有：log4j、slf4j、junit4、ehcache等知识点。 项目...
Spring常见面试题总结（超详细回答）
热门推荐
张维鹏的博客
07-08 90万+
1、Spring是什么? Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架，目的是用于简化企业应用程序的开发，它使得开发者只需要关心业务需求。常见的配置方式有三种：基于XML的配置、基于注解的配置、基于Java的配置。 主要由以下几个模块组成： Spring Core：核心类库，提供IOC服务； Spring Context：提...
Spring——Spring整合MyBatis
★★光亭★★
03-13 2万+
Spring——Spring整合MyBatis
Spring监听器
骑个小蜗牛的博客
12-13 1万+
事件监听概念 应用程序事件允许我们发送和接收特定事件，我们可以根据需要处理这些事件。事件用于在松散耦合的组件之间交换信息。由于发布者和订阅者之间没有直接耦合，因此可以在不影响发布者的情况下修改订阅者，反之亦然。 事件监听三要素 事件源：事件对象的产生者，任何一个事件都有一个来源 ApplicationEvent 事件监听器：事件框架或组件收到一个事件后，需要通知所有相关的事件监听器来进行处理。这些监听器统一存储在事件监听器注册表中。 ApplicationListener（编码式事件监听器） @Event
spring框架特点
weixin_57176230的博客
04-25 6177
框架特点 1.方便解耦、简化开发 通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造 成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写 代码，可以更专注于上层的应用。 2.AOP编程支持 通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通 过AOP轻松应付。 3.声明式事务的支持 在Spring中，我们可以...
Spring Profiles详解
白石的专栏
03-11 7715
Profiles是Spring框架的核心功能——**允许我们将 bean 映射到不同的Profile**——例如，*dev*、*test* 和 *prod*。
Spring配置
Frank---7的博客
01-01 6万+
Spring配置 别名 alias 设置别名 , 为bean设置别名 , 可以设置多个别名 <!--设置别名：在获取Bean的时候可以使用别名获取--> <alias name="userT" alias="userNew"/> Bean的配置 <!--bean就是java对象,由Spring创建和管理--> <!-- id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符 如果配置id,又配置了name,那么name是别名
Spring JDBC
m0_51457307的博客
11-24 6489
Spring JDBC模块负责数据库资源管理和错误处理。 针对数据库操作，Spring框架提供了JdbcTemplate类，该类是Spring JDBC的核心类。 一、Spring JDBC的配置 Spring JDBC主要由4个包组成： Spring JDBC所需要的jar包： Spring对数据库的操作都封装在了这几个包中，想要使用JDBC就需要对其进行配置，在Spring容器中，对JDBC的配置是在applicationContext.xml文件中进行的。 <?xml ..
Spring系列一：Spring基础篇
退役复学在校大学生，目光所至，皆为华夏
07-21 3万+
有人说，“Java程序员都是Spring程序员”，本人不太赞成这个观点，但是这也可以看出Spring在Java世界里举足轻重的作用。
spring security CSRF防护
yjclsx的博客
07-31 45万+
CSRF是指跨站请求伪造（Cross-site request forgery），是web常见的攻击之一。 从Spring Security 4.0开始，默认情况下会启用CSRF保护，以防止CSRF攻击应用程序，Spring Security CSRF会针对PATCH，POST，PUT和DELETE方法进行防护。 我这边是spring boot项目，在启用了@EnableWebSecurity...
Spring Cloud 集成OAuth2实现身份认证和单点登录
07-20
本篇将深入探讨如何利用Spring Cloud集成OAuth2来实现身份认证和单点登录（Single Sign-On，简称SSO）。 OAuth2是一种授权框架，它允许第三方应用获取资源所有者的特定资源，同时保护了资源所有者的隐私信息。在...
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
2. 配置Spring：创建Spring的配置文件，如applicationContext.xml，配置Bean、DataSource、TransactionManager等。 3. 配置SpringMVC：创建SpringMVC的配置文件，如servlet-context.xml，配置DispatcherServlet、...
阿博图书馆管理：SpringBoot实战指南
2402_85761468的博客
09-27 694
MySQL数据库中数据的分表分库存储方式能够最大程度的避免数据同步代码的性能损耗，使得数据库的存取速度有了很大提升，而且同时保持了很大的灵活性。通过对系统功能模块分析可以得知，主要是对项目元素组合、分解和更换做出相应的单元，再通过系统模块来规划出一个原则，系统的设计首先是围绕用户需求进行开发设计的，主要是为了能够更好的管理信息和方便用户，其次就是围绕阿博图书馆管理系统进行设计，最终的设计必须要满足用户的需求，这样才能够实现系统的最大意义和价值，并且在设计的时候一定要避免代码相互重复的情况发生。
springboot+neo4j demo
极客栈
09-27 613
这个简单的示例展示了如何在Spring Boot应用中集成Neo4j，包括创建节点实体、使用Neo4j仓库接口以及创建一个简单的REST控制器。这个示例可以作为开发者学习和实践Spring Boot与Neo4j集成的起点。以下是一个简单的Spring Boot与Neo4j集成的示例代码。
基于SpringBoot原创歌曲分享平台设计与实现
zhshx19900318的博客
09-29 832
在这样的背景下人类社会进入了全新的信息化的时代。在音乐分享管理页面中可以查看索引,音乐分类，音乐名称，音乐视频，区域，视频封面，发布时间，歌词，用户账号，用户姓名等内容，并进行详情，修改，查看评论和删除操作；在举报管理页面中可以查看索引,音乐名称，发布时间，用户账号，用户姓名，举报原因，审核回复，审核状态，审核等内容，并进行详情，修改，删除操作；
spring-boot 整合 mybatis
m0_72168501的博客
09-29 457
spring boot 整合 mybatis
微服务--SpringAMQP
weixin_51933701的博客
09-27 1312
高级消息队列协议，是应用程序之间传递业务消息的开放标准，与语言和平台无关，更符合微服务架构中独立性的要求。：基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息。是基础抽象，是底层的默认实现。SpringAMQP利用SpringBoot实现了自动装配，使用非常方便。
SpringBoot实现社区医院数据集成解决方案
最新发布
2401_85743969的博客
10-01 781
同时，一个大型的计算机网站系统，必须有一个正确的设计指导思想，通过合理选择数据结构、网络结构、操作系统以及开发环境，构成一个完善的网络体系结构，才能充分发挥计算机信息管理的优势。随着计算机技术的发展以及计算机网络的逐渐普及，互联网成为人们查找信息的重要场所，二十一世纪是信息的时代，所以信息的管理显得特别重要。随着互联网技术的快速发展，网络时代的到来，网络信息也将会改变当今社会。2.高可靠性：一个实用的网站同时必须是可靠的，本设计通过合理而先进的网络设计以及软、硬件的优化选型，可保证网站的可靠性与容错性。
精通Spring 2：英文原版指南
" Beginning Spring 2：from novice to professional 是一本由 Dave Minter 撰写的英文原版书籍，旨在帮助读者从入门到精通 Spring 框架。该书由 Apress 出版，并在 2008 年由 Kahle/Austin Foundation 资助数字化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值