Spring—IoC与Aop总结及Spring+mybatis整合

最新推荐文章于 2024-07-16 22:26:32 发布
最新推荐文章于 2024-07-16 22:26:32 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： spring java 文章标签： spring mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhq0625/article/details/108183974
版权
java 同时被 2 个专栏收录
12 篇文章 0 订阅
订阅专栏
spring
2 篇文章 0 订阅
订阅专栏

1、Spring的体系结构

在这里插入图片描述

1）test测试部分

spring test：主要为测试提供支持的，支持使用JUnit或TestNG对Spring组件进行单元测试和集成测试，它提供了Spring ApplicationContext的一致加载和这些上下文的缓存。

2)Core container 核心容器

  • spring core：提供了框架的基本组成部分，包括控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）功能，核心API。
  • spring beans：提供了BeanFactory，是工厂模式的一个经典实现，Spring将管理对象称为Bean，IoC部分，如何创建对象，控制反转。
  • spring context：构建于 core 封装包基础上的 context 封装包，提供了一种框架式的对象访问方法，上下文，读取配置文件等内容。
  • spring expression(SpEL):模块是统一表达式语言(unified expression language，unified EL)的扩展，用于在运行时查询和操作对象图。该语言支持设置和获取属性值、属性赋值、方法调用、访问数组、集合和索引的内容、逻辑和算术操作符、命名变量，以及从Spring的IoC容器按名称检索对象。还支持列表映射、选择以及常见的列表聚合。

3)AOP 和 Instrumentation、Messaging

  • spring aop：提供面向切面的编程实现，允许你定义方法拦截器和切入点对代码干净地解耦分离。

  • spring aspects：集成自 AspectJ 框架， 主要是为 Spring AOP 提供多种 AOP 实现方法

  • spring instrument：提供用于某些应用服务器的类instrumentation 支持和类加载器实现。

  • Spring Framework 4 ：包含spring-messaging模块，来自Spring集成项目的抽象，如Message、MessageChannel、MessageHandler等，用来提供基于消息的基础服务。该模块还包括一组用于将消息映射到方法的注解，类似于基于编程模型的Spring MVC的注解。

4）数据访问和集成

  • spring jdbc：提供了一个JDBC的抽象层，消除了烦琐的JDBC编码和数据库厂商特有的错误代码解析， 用于简化JDBC。主要是提供JDBC模板方式、关系数据库对象化方式、SimpleJdbc方式、事务管理来简化JDBC编程，主要实现类是 JdbcTemplate、SimpleJdbcTemplate 以及 NamedParameterJdbcTemplate
  • spring orm：为流行的 object-relational mapping（对象-关系映射）API(包括JPA、JDO和Hibernate)提供了集成层。使用spring-orm模块，可以结合O/R映射框架与Spring提供的所有其他特性结合，如简单声明性事务管理特性。
  • spring oxm：提供了一个抽象层用于支持 Object/XML mapping （对象/XML映射）的实现，如JAXB、Castor、XMLBeans、JiBX和XStream。
  • spring jms：包含生成和消费消息的功能。从Spring4.1开始，提供了与spring-messaging模块的集成。

5）Web

  • spring Web：提供了针对 Web 开发的集成特性，例如文件上传，利用 servlet listeners 进行 ioc 容器初始化和针对 Web 的 ApplicationContext。
  • spring websocket：主要是与 Web 前端的全双工通讯的协议。
  • spring webmvc-portlet ：(也称为Web-Portlet模块)提供了要在Portlet环境中使用的MVC实现，并反映了基于servlet的spring-webmvc模块的功能。（该模块在Spring5中移除）
  • spring webflux：一个新的非堵塞函数式 Reactive Web 框架， 可以用来建立异步的、非阻塞、事件驱动的服务，并且扩展性非常好。

2、Spring中用到了哪些设计模式

  1. 工厂模式：BeanFactory就是简单工厂模式的体现，用来创建对象的实例；
  2. 单例模式：Bean默认为单例模式。
  3. 代理模式：Spring的AOP功能用到了JDK的动态代理和CGLIB字节码生成技术；
  4. 模板方法：用来解决代码重复的问题。
  5. 观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现–ApplicationListener。

3、Spring Beans

在Java中Bean 分两种类型：
1、封装数据的JavaBean：实体类
满足如下要求 :

  • 提供公共的无参数的构造函数 。
  • 属性要private。
  • 对私有属性封装成对应的get 及set方法。

2、封装业务的JavaBean serviceImpl
要求：

  • 公共的无参数的构造函数
  • 公共的业务方法

自己创建Bean（对象）的缺点：耦合性强

4、Spring IoC的实现

把对象的创建、管理的权限交由Spring框架管理–控制反转IoC
Spring体系结构中的Beans部分就是IoC
分析、实现spring是如何创建bean—自行封装实现

实现思路：

创建配置文件 MyBean.properties
在工厂中，根据参数，创建对应名字的bean
调用工厂，得到了bean

public class BeanFactory {
    public  static Object getBean(String name) throws ClassCastException, IllegalAccessException, InstantiationException, IOException, ClassNotFoundException {
        FileInputStream fileInputStream=new FileInputStream("src/main/resources/MyBeans.properties");
        Properties properties=new Properties();
        properties.load(fileInputStream);
        String className=properties.getProperty(name);
        Object obj=Class.forName(className).newInstance();
        return  obj;

    }
}

如何通过Spring 来创建对象

实现步骤：
1.添加Spring的jar依赖

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.1.6.RELEASE</version>
</dependency>

2.编写配置文件，名字任意 spring-context.xml， 编写要创建的bean对象

<!--配置要创建bean的类-->
<!--id:称为对象的标识，在同一配置文件中id不能重复，因为创建的对象都在同一容器中，class:类的完整限定名-->
<bean id="ud" class="com.dl.dao.impl.UserDapImpl"></bean>
<bean id="us" class="com.dl.service.impl.UserServiceImpl" scope="singleton">
       <!--给UserServiceImpl对象的属性通过setUserDao()给userDao属性进行赋值-->
       <!--在配置文件中给属性赋值，称为DI，就是依赖注入-->
       <!--注入方式：设值注入，通过setXXX()方法赋值-->
       <property name="userDao" ref="ud"></property>
</bean>

3.通过ApplicationContext来获取Spring创建的bean
ClassPathXmlApplicationContex 工厂类

ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring-context.xml");
//根据配置的id值获取
UserDao userDao=(UserDao) applicationContext.getBean("ud");
System.out.println("通过Spring获取的bean地址："+userDao);
userDao.insertUser();

【结论】Spring创建的Bean 默认是单例模式
scope=“prototype” bean的作用域，默认是单例模式
prototype 原型模式，调用一次创建一个对象
singleton 单例模式

5、Spring注入bean的几种方式

方式1：set注入 设值注入，通过setXXX()方法进行注入

<bean id="ud" class="com.qf.springpro2001.dao.impl.UserDaoImpl"></bean>
<bean id="us" class="com.qf.springpro2001.service.impl.UserServiceImpl" scope="singleton">
    <!--给UserServiceImpl对象的属性通过setUserDao()给userDao属性进行赋值-->
    <!--在配置文件中给属性赋值，称为DI，就是依赖注入-->
    <!--注入方式：设值注入，通过setXXX()方法赋值-->
    <property name="userDao" ref="ud"></property>
</bean>

方式2：构造注入 通过构造函数进行注入

<bean id="zhaoyan" class="com.qf.springpro2001.test.Student">
    <!--构造注入：通过构造函数给属性赋值，要求类必须有对应的构造函数-->
    <!--name:形参的名字    value:形参的值-->
    <constructor-arg name="stuNo" value="java101"></constructor-arg>
    <constructor-arg name="stuName" value="赵"></constructor-arg>
    <constructor-arg name="stuSex" value="男"></constructor-arg>
</bean>

方式3：自动注入 在bean标签里加 autowire=“byName”
要求对象的id值和属性的名字要相同
byName 同名自动赋值
byType 同一类型自动赋值

<!--自动注入   id值和对象的属性名一致-->
<bean id="userService" class="com.qf.springpro2001.service.impl.UserServiceImpl" autowire="byType"></bean>

6、在spring中BeanFactory 、FactoryBean 区别？

  • BeanFactory：Bean工厂，生产创建Bean,ClassPathXmlApplicationContext Bean工厂之一
  • FactoryBean：是一个复杂的Bean /类，实现了FactoryBean接口的类，称为FactoryBean

7、Bean的创建时间：

1）饿汉模式，在启动BeanFactory时就创建Bean。默认的就是饿汉模式：提前创建好Bean ,随用随取。
2）懒汉模式，在启动BeanFactory时不创建Bean。调用getBean()时，才去创建Bean，在beans标签中设置：default-lazy-init=“true”。
【说明】为了节省内存推荐懒汉模式

8、Bean的作用域

  • singleton : bean在每个Spring ioc 容器中只有一个实例。
  • prototype：一个bean的定义可以有多个实例。
  • request：每次http请求都会创建一个bean，该作用域仅在基于web的Spring ApplicationContext情形下有效。
  • session：在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。
  • global-session：在一个全局的HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。

9、Bean的生命周期

从创建到销毁的中间的各个过程
两个重要阶段：

  •  bean的初始化 new之后被调用
  •  bean的销毁

实现方式1：通过配置，调用自定义的初始化方法及销毁方法
                    init-method=“myInitBook” destroy-method=“myDestroyBook”
实现方式2：Bean 直接实现初始化及销毁的相关接口，实现对应接口的方法接口，自动调用
                  implements InitializingBean, DisposableBean
无需设置 init-method=“myInitBook” destroy-method=“myDestroyBook”
实现方式3：注解
单例模式Bean的生命周期： 创建-》构造函数-》调用set方法赋值-》初始化方法
-》使用bean->销毁(bean工厂关闭销毁经即可)

多例模式Bean的生命周期：创建-》构造函数-》调用set方法赋值-》初始化方法
-》使用bean->等待垃圾回收机制GC进行销毁

10、代理设计模式（静态代理/动态代理）

1、静态代理：代理固定的类型
2、动态代理 ：
动态代理实现有两种方式：

总结：jdk 和 cglib二者的区别

1、jdk利用反射机制生成一个代理接口的匿名类，在调用具体方法前，使用InvocationHandler接口，Cglib 利用ASM框架，对代理类 通过修改其字节码生成子类来处理。
2、【强调】jdk动态代理只能对实现了接口的类生成代理，不能直接针对类，cglib可以直接针对类实现代理。
3、什么时候使用cglib 什么时候使用jdk动态代理？

  • 目标代理对象实现了接口，默认使用jdk动态的代理，也可以指定使用cglib动态代理。
  • 如果没有实现接口，必须采用cglib动态代理。

4、效率上

  • jdk6以后 由于对jdk动态代理进行优化，所有当调用次数较少时，jdk效率高
  • 大量调用时cglib效率高
  • jdk8及以后 jdk效率高于cglib

【特别强调】cglib不能对final类及final修饰的方法进行代理
sping框架，同时使用了jdk cglib动态代理

11、Spring Aop的实现

1.Aop解决的问题：

​ 把编程的重点放在核心业务上，把“公共的”业务，进行配置，配置后，在执行核心业务的同时，公共业务能够自动执行， 从而减轻了业务的复杂度。

2.Aop原理：动态代理，当执行到核心功能时，代理去执行“公共的”业务。

​ 作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。可用于权限认证、日志、事务处理等。

3.Aop相关概念

切面（Aspect）：切面是通知和切点的结合。通知和切点共同定义了切面的全部内容。 在Spring AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @AspectJ 注解来实现。

连接点：把程序中的核心方法 进行封装 JoinPoint，在“公共的”业务中，通过连接点对象(JoinPoint)就可以获取核心方法信息。

切入点：Pointcut 就是核心业务方法。切点的定义会匹配通知所要织入的一个或多个连接点。我们通常使用明确的类和方法名称，或是利用正则表达式定义所匹配的类和方法名称来指定这些切点。

通知/增强Advice：在不同的时间点所执行的“公共”业务，称为通知或增强

执行的时间点不同，增强/通知就不同

  • 在执行核心方法前，所执行的公共业务，称为前置增强/通知
<aop:before method=“beForeOper” pointcut-ref=“insertUserPointCut”/>
  • 在执行核心方法后，所执行的公共业务，称为后置增强/通知
<aop:after-returning method=“afterOper” pointcut-ref=“insertUserPointCut returning=“result”/>
  • ​ 在执行核心方法发生异常时，所执行的公共业务，称为 异常处理增强
<aop:after-throwing method=“catchExecption” pointcut-ref=“insertUserPointCut”
 throwing=“ex”/>
  • ​ 在执行核心方法的finally语句，执行的公共业务，称为 最终增强
<aop:after method=“runFinally” pointcut-ref=“insertUserPointCut”/>

环绕增强：以上4种增强的统称，简化了以上4种增强。

目标对象（Target Object）： 被一个或者多个切面（aspect）所通知（advise）的对象。它通常是一个代理对象。也有人把它叫做 被通知（adviced） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。

织入（Weaving）：织入是把切面应用到目标对象并创建新的代理对象的过程。在目标对象的生命周期里有多少个点可以进行织入：

  • 编译期：切面在目标类编译时被织入。AspectJ的织入编译器是以这种方式织入切面的。
  • 类加载期：切面在目标类加载到JVM时被织入。需要特殊的类加载器，它可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5的加载时织入就支持以这种方式织入切面。
  • 运行期：切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。SpringAOP就是以这种方式织入切面。
<aop:aspect ref="doException">
    <!--织入：把增强方法和切入点(类)组合在一起的过程-->
    <!--织入异常处理通知-->
    <!--织入后，springAop创建代理对象Proxy-->
    <aop:after-throwing method="catchExecption" pointcut-ref="insertUserPointCut"
    throwing="ex"/>

    <!--织入最终增强方法-->
    <aop:after method="runFinally" pointcut-ref="insertUserPointCut"/>

</aop:aspect>

4.SpringAop的使用步骤
1、添加Aop的依赖
2、在spring的配置文件中，添加aop相关的命名空间
3、编写核心方法

  • UserDao :interface insertUser()
  • UserDaoImpl:class 实现方法
  • ​ UserService:interface insertUser()
  • ​ UserServiceImpl:class 实现方法

4、添加log4j的相关配置信息
5、编写公共业务方法–单独提取出来编写，异常处理 日志记录，aop
6、在配置文件中进行配置

12、环绕增强 重点

环绕增强：实现了4种增强，进行了简化

public class Arround {
    private final Logger logger=Logger.getLogger(Arround.class);
    //环绕增强只需要一个方法即可
    public Object doArround(ProceedingJoinPoint jp){
        //存放切入点的返回值
        Object result=null;
        //编写相当于前置增强要执行的代码
        logger.debug("环绕增强前置---执行了"+jp.getTarget()+"类里的"+jp.getSignature()+"方法"+
                "方法的参数是："+ Arrays.toString(jp.getArgs()));
        try{
            //执行核心方法，切入点对应的方法
            result=jp.proceed();
            //后置增强
            logger.debug("环绕增强后置---"+jp.getSignature()+"方法被执行，返回值为："+result);
        }catch (Throwable e) {
            //相当于异常处理增强
            logger.error("环绕增强异常处理---"+jp.getSignature()+"方法发生异常，异常信息如下："+e.getMessage());
            e.printStackTrace();
        }finally {
            //最终增强
            logger.debug("环绕曾强强最终处理---"+jp.getSignature()+"执行结束");
        }
        return result;
    }
}

 

<!--配置切入点-->
        <asp:pointcut id="updateUserPointCut"
                      expression="execution(public int updateUser(String,int))"></asp:pointcut>

 

<!--配置环绕增强-->
        <aop:aspect ref="arround">
            <aop:around method="doArround" pointcut-ref="updateUserPointCut"></aop:around>
        </aop:aspect>

13、增强/通知 实现接口的方式，实现Aop

aop:after-throwing   异常处理增强
aop:after            最终增强
aop:before           前置增强
aop:after-returning  后置增强
aop:around           环绕增强

代理通过标签的读取，在什么时间执行什么方法

另一种方式，通过实现接口来决定执行时间点

  • 前置通知：MethodBeforeAdvice
  • 后置通知：AfterAdvice finally语句块中
  • 后置通知：AfterReturningAdvice //有异常不执行，方法会因异常而结束，无返回值
  • 异常通知：ThrowsAdvice
  • 环绕通知：MethodInterceptor

14、通用表达式 重要

采用通用的方式，去声明切入点，简化了配置

通用方式语法：

execution(访问修饰符 返回值类型(必填) 所在的包和类 方法名(必填)(参数类型列表) )

1）、execution(* com.qf.springpro2001.service.impl.inserUser())

返回值类型任意的 com.qf.springpro2001.service.impl包下的insertUser无参方法 是切入点

2）、execution( void com…*.updateUser())

访问修饰符任意的 返回值类型是void的com包下的所有类，及其子包下所有类的updateUser无参方法是切入点

3）、execution(* save(…))

访问修饰符任意的，返回值任意的，任意包下的save方法， 方法参数是任意

4）、executiion(* *(…))

所有方法

execution(public * com.qf.springpro2001.service.impl..*.*(..))"
修饰符是public的   com.qf.springpro2001.service.impl包及其子包下的所有类的所有方法

15、后置处理Bean

目前的Bean的声明周期：

创建bean->构造函数->set()->检验是否实现初始化接口->检验是否配置了init-method->使用->检验是否实现了销毁接口->是否配置了destroy-method

JDK1.8开始BeanPostProcessor接口里的方法已经在接口中实现，无需在实现类中再重写

在JDK1.8之前，实现类必须实现BeanPostProcessor接口中的方法

16、Spring+mybatis进行整合

1、新建项目

2、添加jar依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.1.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.1.6.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.6.RELEASE</version>
</dependency>

<!-- Spring整合mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.1</version>
</dependency>

<!-- MyBatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.5</version>
</dependency>

<!-- mysql驱动 依赖 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.25</version>
    <scope>runtime</scope>
</dependency>

<!-- 连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.12</version>
</dependency>

3、改变 映射文件的存放位置

<build>
    <!-- 更改maven编译规则 -->
    <resources>
        <resource>
            <!-- 资源目录 -->
            <directory>src/main/java</directory>
            <includes>
                <include>*.xml</include><!-- 默认（新添加自定义则失效） -->
                <include>**/*.xml</include><!-- 新添加 */代表1级目录 **/代表多级目录 -->
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

4、编写数据库连接的配置文件 jdbc.properties配置文件

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_shopping?useUnicode=true&characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root
jdbc.init=1
jdbc.minIdle=1
jdbc.maxActive=3

5、编写spring配置文件 spring-context.xml

        <!--数据库配置信息文件的位置-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!--原来在Mybatis中配置数据源连接池信息，整合后，拿到spring中配置-->
    <!--配置Druid连接池：详细参数配置-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--通过设值注入给属性赋值-->
        <!--基本配置-->
        <property name="driverClassName" value="${jdbc.driverClass}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>

        <!--初始化连接数量   最小空闲数量   最大活跃数量-->
        <property name="initialSize" value="${jdbc.init}"></property>
        <property name="minIdle" value="${jdbc.minIdle}"></property>
        <property name="maxActive" value="${jdbc.maxActive}"></property>

        <!--配置获取连接的超时的时间-->
        <property name="maxWait" value="60000"></property>
        <!--配置检查的时间间隔：检查需要关闭的空闲连接的时间间隔，单位ms-->
        <property name="timeBetweenEvictionRunsMillis" value="60000"></property>

        <!--配置连接池中最小生存的时间-->
        <property name="minEvictableIdleTimeMillis" value="30000"></property>
    </bean>

    <!--创建mybatis操作数据库是需要的SqlSeesionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--为其注入属性值-->
        <property name="dataSource" ref="dataSource"></property>
        <!--告知Mybatis接口对应的映射文件的位置-->
        <property name="mapperLocations">
            <list>
                <value>classpath:com/qf/sam/dao/*.xml</value>
            </list>
        </property>
        <!--配置实体类的别名-->
        <property name="typeAliasesPackage" value="com.qf.sam.entity"></property>
     </bean>
    <!--配置MapperCannerConfigurer  在dao中通过此配置就可以得到sqlSession-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--dao接口所在的包：如果接口在多个包中，可以使用逗号进行分割-->
<!--        <property name="basePackage" value="com.qf.sam.dao,com.qf.sam.entity"></property>-->
        <property name="basePackage" value="com.qf.sam.dao"></property>
        <!--配置得到sqlSession需要的sqlSessionFactory
           【说明】引入另一个对象时，需要使用ref进行引入，但是此处通过value引入
        -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>

6、编写dao及mapper.xml映射文件，和以往没有任何变化

7、编写service及实现类

//利用springIoC实现了解耦
private DeptDao deptDao;

public void setDeptDao(DeptDao deptDao) {
this.deptDao = deptDao;
}

public boolean insertDept(Dept dept) {
int result=deptDao.insertByBach(dept);
if (result==1){
return true;
}else{
return false;
     }
}

8、spring-context.xml配置文件中

<bean id="ds" class="com.qf.sam.service.impl.DeptServiceImpl">
    <!--mybatis创建的dao的对象，deptDao
    dao接口名字的首字母小写-->
    <property name="deptDao" ref="deptDao"></property>
</bean>

9、测试


public static void main(String[] args) {
    ApplicationContext applicationContext=new
            ClassPathXmlApplicationContext("spring-context.xml");
    DeptService ds=(DeptService)applicationContext.getBean("ds");
    Dept dept=new Dept();
    dept.setDeptName("软件开发超级俱乐部");
    dept.setDeptLoc("软件园15号楼");
    boolean result=ds.insertDept(dept);
    if (result){
        System.out.println("添加成功！");
    }else {
        System.out.println("添加失败！");
    }
}
骡子骑马找骆驼
关注
专栏目录
Spring知识点总结
qq_1365343049的博客
03-16 351
1.Spring 1.1简介 Spring：春天----------------->给软件行业带来了春天 SSH：Struct+Spring+Hibernate SSM：SpringMVC+Spring+Mybatis 官网：https://spring.io/projects/spring-framework#overview maven <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --&g
spring的IOC和AOP
weixin_33851429的博客
10-15 64
spring的IOC和AOP 1.解释spring的ioc? 几种注入依赖的方式？spring的优点？ IOC你就认为他是一个生产和管理bean的容器就行了，原来需要在调用类中new的东西，现在都是有这个IOC容器进行产生， 同时，要是产生的是单例的bean，他还可以给管理bean的生命周期！ spring的IOC有三种注入方式 ： ...
Spring框架(IOC和AOP详解)
最新发布
happysmooth的博客
07-16 915
参数名注入是有限制的，需要在编译时打开调试模式（即在编译时使用“javac –g:vars”选项,在class文件中生成变量调试信息，默认是不包含变量调试信息的），否则获取不到参数名字，或在构造器上使用注解@ConstructorProperties来指定参数名。由于spring在解析切点的定义时(org.springframework.aop.aspectj.AspectJExpressionPointcut)，使用的是aspectj的工具类，所以需要导入aspectjweaver.jar。
Spring的IoC和AOP
春卷同学的博客
07-08 441
IoC Ioc（Inversion of Control，控制反转）是一种设计思想。 所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对...
Spring的IOC和AOP概念和实现原理
qq_52324490的博客
12-12 1061
一、IOC（Inverse of Control）控制反转 1.依赖注入DI（dependency injection） 所谓依赖，从程序的角度看，就是比如 A 要调用 B 的方法，那么 A 就依赖于 B，反正 A 要用到 B，则 A 依赖于 B。所谓倒置，你必须理解如果不倒置，会怎么着，因为 A 必须要有 B，才可以调用 B，如果不倒置，意思就是 A 主动获取 B 的实例：B b = new B ()，这就是最简单的获取 B 实例的方法（当然还有各种设计模式可以帮助你去获得 B 的实例，比如工厂、Loca
SpringMVC+Spring+Mybatis集成开发环境
04-28
Mybatis的配置文件会与Spring整合，将Mapper接口和XML配置映射到Spring Bean中，实现DAO层的无代码侵入式操作。 在实际开发中，一般步骤如下： 1. 配置Spring的IoC容器，定义Bean的定义和依赖关系。 2. 配置...
aven2+spring(ioc aop)+struts+mybatis
03-18
本项目标题提及的是"aven2+spring(ioc aop)+struts+mybatis"，这四者是Java Web开发中的经典组合，被称为SSH2（Struts2、Spring、Hibernate和MyBatis）。尽管这里的"Hibernate"未在描述中出现，但通常与MyBatis一起...
Spring + Spring Boot + MyBatis + MongoDB的整合教程
08-28
Spring框架是Java开发中广泛使用的轻量级框架，它的核心是IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）。Spring Boot是Spring的扩展，它简化了Spring应用的初始搭建...
Java EE 框架整合开发⼊⻔到实战——Spring+Spring MVC+MyBatis（微课版）课后习题答案.pdf
06-18
这份文档名为《Java EE 框架整合开发入门到实战——Spring+Spring MVC+MyBatis（微课版）课后习题答案.pdf》，它显然是关于Java EE中流行的三个框架整合使用的教程。这三个框架分别是Spring、Spring MVC和MyBatis，...
Spring+SpringMvc+Mybatis学生管理系统
06-19
此外，Spring还提供了AOP（面向切面编程）功能，方便进行日志记录、事务管理等跨切面操作。 2. **SpringMVC**：SpringMVC是Spring框架的一个模块，专门处理Web层的请求和响应。它将MVC设计模式应用于Java Web开发，...
Spring之IOC和AOP
朱登凯的专栏
10-15 2291
Spring是一个开源框架，主要实现两件事，IOC（控制反转）和AOP（面向切面编程）。 IOC 所谓控制反转，就是控制权的转移，举例说明：一个人要开车，正常情况下，人应该自己去找车，而实现控制反转后，人就不需要考虑车从哪里来了，直接开就行了，人就把找车的控制权转移给了别的对象。体会一下下面的代码 先定义一个接口Car public interface Car { void...
spring的Ioc和AOP
心疼笔记本
06-03 390
spring的Ioc（控制反转和依赖注入）  控制反转：就是由容器控制程序之间的（依赖）关系，而非传统实现中，由程序代码直接操控         依赖注入：组件之间的依赖关系由容器在运行期决定 ，由容器动态的将某种依赖关系注入到组件之中 。 在以往的JDBCTemplate中事务提交成功，异常处理都是通过Try/Catch 来完成，而在Spring中。Spring
Spring中的IOC和AOP
风水道人
05-06 207
Spring 能帮我们做什么 Spring是为解决企业级应用开发的复杂性而设计的一款框架，Spring的设计理念就是：简化开发。 在Spring框架中，一切对象都是bean，所以其通过面向bean编程（BOP），结合其核心思想依赖注入（DI）和面向切面(（AOP）编程，Spring实现了其伟大的简化开发的设计理念。 控制反转（IOC） IOC全称为：Inversion of Control。控制反转的基本概念是：不用创建对象，但是需要描述创建对象的方式。 简单的说我们本来在代码中...
JAVA面试题分享二百二十六：IoC & AOP详解
之乎者也·的博客
12-13 924
IoC （Inversion of Control ）即控制反转/反转控制。它是一种思想不是一个技术实现。描述的是：Java 开发领域对象的创建以及管理的问题。例如：现有类 A 依赖于类 B传统的开发方式：往往是在类 A 中手动通过 new 关键字来 new 一个 B 的对象出来使用 IoC 思想的开发方式：不通过 new 关键字来创建对象，而是通过 IoC 容器(Spring 框架) 来帮助我们实例化对象。我们需要哪个对象，直接从 IoC 容器里面过去即可。
Spring的AOP理解
m0_48943844的博客
12-14 388
OOP面向对象，允许开发者定义纵向的关系，但并不适用于定义横向的关系，会导致大量代码的重复，而不利于各个模块的重用。 AOP，一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。 AOP实现的关键在于 代理模式，AOP代理主要分为静态代理和动态代理。静态代理的代表为AspectJ；动..
Spring：IOC和AOP
机械工程跑路哥
03-16 3490
IOC(控制反转)和AOP(面向方面编程)作为Spring框架的两个核心，可以很好地实现解耦合。
Struts2参数传递与Spring+MyBatis整合教程
Spring则是轻量级的IoC（ inversion of control）和AOP（面向切面编程）容器框架，旨在解决传统J2EE应用开发中的复杂性和效率问题。Spring通过将业务逻辑与基础设施解耦，使得开发者可以专注于核心业务逻辑，而不受...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值