第五章spring框架基础

最新推荐文章于 2022-09-01 15:58:33 发布
最新推荐文章于 2022-09-01 15:58:33 发布
阅读量196 收藏
点赞数
分类专栏： 笔记 SSM企业轻量级开发框架 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NYLX9527/article/details/117676544
版权

spring框架

一.spring

概念:

Spring是由Rod Johnson开发的一个开源容器框架,提供了控制反转[IoC],依赖注入,面向切面[AOP],事务管理,框架整合等功能,用于简化企业级应用开发.
特点:
1.轻量级:
Spring提供了许多服务,但这些服务默认关闭.同时,完整的Spring框架可以以在1M多大小的jar文件发布.
2.控制反转:
应用本身不负责依赖对象(被调用对象)的创建及维护,由外部容器负责依赖对象的创建及维护.
3.面向切面:
在运行时,动态的将代码切入到类的指定方法或位置上.
4.容器:
Spring包含并管理应用对象的配置和生命周期,因此Spring称为容器.

下载Spring:
官网地址:http://www.springsource.org/download
下载地址:https://repo.spring.io/libs-release-local/org/springframework/spring/

JDK与版本:
Spring Framework3.x: JDK5+
Spring Framework4.x: JDK6+
Spring Framework5.x: JDK8+

开发步骤:

第1步: 添加jar包

    commons-logging-1.2.jar 
    spring-aop-5.1.2.RELEASE.jar
    spring-beans-5.1.2.RELEASE.jar
    spring-context-5.1.2.RELEASE.jar
    spring-core-5.1.2.RELEASE.jar
    spring-expression-5.1.2.RELEASE.jar

添加jjar包

第2步: 创建Java类

    创建1个实体类
    备注: 测试Spring框架控制实体类[创建实体类,提供实体类对象]

实体类

第3步: 创建Spring配置文件

配置文件名称[beans.xml,application.xml,spring.xml,spring-bean.xml等等]任意,位置不限[src下].

配置文件模板位置[参考pdf或html]
创建配置文件信息

第4步: 编写Spring配置文件

   <bean>用于将指定位置的Java类,交给Spring容器管理[控制反转(帮你创建对象),依赖注入(向你提供对象)等等]
   示例:
   <bean class="bean.User" id="myuser" />

编写配置文件信息

第5步: 测试程序

    public static void main(String[] args) {
        //读取配置文件
        ApplicationContext app=new ClassPathXmlApplicationContext("配置文件名.xml");
        //从Spring容器中获得1个对象
        Object object= (Object ) app.getBean("id匿名");//Object-->User
        user.setName("小白");
        System.out.println(user);
    }

测试程序实例

二 .控制反转

概念:

控制反转[Inversion of Control]指应用本身不负责依赖对象(被调用对象)的创建及维护,由外部容器负责依赖对象的创建及维护.

控制反转实现方式:

第1种: 构造方法
<bean id="Bean匿名" class="类全名" />
![对象的构造函数](https://img-blog.csdnimg.cn/20210607231802196.png)
第2种: 工厂类的静态方法
<!-- Bean匿名=工厂类.静态方法名() -->
<bean id="Bean匿名" class="工厂类全名" factory-method="静态方法名"/>
![工厂类的静态方法](https://img-blog.csdnimg.cn/20210607231848352.png)

创建工厂
工厂静态方法测试类

第3种: 工厂类的对象方法
<bean id="别名A" class="工厂类全名"/>
<bean id="别名" factory-bean="别名A"  factory-method="方法名"/>

在这里插入图片描述

第4种: 注解方式
	a.添加context命名空间和context约束文件的地址
	b.添加<context:component-scan base-package="包名">
	c.在相关类上添加注解:
	注解: @Controller[标注在Action类上],@Service[标注在业务类上],@Repository,@Component[无法分辨层级,比如实体]
	作用: 声明将当前类交给Spring容器管理.
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210607232838939.png)

添加注释
测试类

三.依赖注入

概念:

依赖注入[Dependency Injection]指在运行期,由外部容器动态地将依赖对象[要使用的对象]注入到组件中.
注意: 依赖注入的前提是控制反转,被注入对象和接受注入的对象都必须被Spring容器管理.

依赖注入实现方式

方式1: setter方式
Java类:
private 普通属性类型 属性名;
private 自定义类类型 属性名;
private 集合类型 属性名;
//提供setter和getter
配置文件:
<bean id="Bean对象匿名" class="类全名">
	<property name="属性名" value="值" />
	<property name="属性名" ref="Bean对象匿名" />
	<property name="属性名">
		<list>\<value>
		<set>\<value>
		<map>\<entry>
		<props>\<prop>
	</property>
</bean>

//使用setter方式示例代码
<bean class="bean.Car" id="car"/>
<bean id="di_setter" class="bean.DI_Setter">
    <!--1.setter方式-->
    <!--普通数据-->
    <property name="id" value="1"/>
    <property name="name" value="小蜜瓜"/>
    <property name="income" value="12000"/>
    <property name="sex" value="女"/>
    <property name="marry" value="true"/>
    <!--对象数据-->
    <property name="car" ref="car"/>
    <!--集合数据-->
    <property name="myList" >
        <list >
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </list>
    </property>
    <property name="myMap">
        <map>
            <entry key="a" value="1"/>
            <entry key="b" value="2"/>
            <entry key="b" value="3"/>
        </map>
    </property>
    <property name="mySet">
        <set>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </set>
    </property>
</bean>
方式2: 构造函数
Java类:
private 普通属性类型 属性名;
private 自定义类类型 属性名;
private 集合类型 属性名;
//提供有参构造方法
配置文件:
<bean id="Bean对象匿名" class="类全名">
	<constructor-arg index="参数索引" value="值" />
	<constructor-arg index="参数索引" type="类全名" ref="Bean对象匿名" />
	<constructor-arg index="参数索引" >
		<list/set/map/props>[参考setter方式]
	</constructor-arg>
</bean>

//构造函数使用示例
 <bean class="bean.Car" id="car"/>
<bean id="di_setter" class="bean.DI_Setter">
    <!--1.构造函数方式-->
    <!--普通数据--> 
    <constructor-arg name="id" value="1"/>
    <constructor-arg name="name" value="小蜜瓜"/>
    <constructor-arg name="income" value="12000"/>
    <constructor-arg name="sex" value="女"/>
    <constructor-arg name="marry" value="true"/>
    <!--对象数据-->
    <constructor-arg name="car" ref="car"/>
    <!--list集合数据-->
    <constructor-arg name="myList" >
        <list >
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </list>
    </constructor-arg>
    <!---map集合数据-->
    <constructor-arg name="myMap">
        <map>
            <entry key="a" value="1"/>
            <entry key="b" value="2"/>
            <entry key="b" value="3"/>
        </map>
    </constructor-arg>
     <!--set方法-->
    <constructor-arg name="mySet">
        <set>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </set>
    </constructor-arg>
</bean>
方式3: 注解方式

Java类与配置文件:
a.配置文件中context命名空间和context约束文件的地址
在这里插入图片描述

b.配置文件中添加<context:component-scan base-package=“包名” />
在这里插入图片描述

c.在Java类的属性或setter上添加注解: @Autowired或@Resource.
在这里插入图片描述

@Autowired:
格式: @Autowired [(required=true)]
说明:
1.编写在属性或setter上,表示将Spring容器中同类型的Bean对象赋给该属性
2.根据属性类型到Spring容器中寻找bean对象,然后注入依赖对象
3.required默认为true,即配置文件中必须有同类型的Bean对象,否则报错

@Resource:
格式: @Resource[(name=“Bean对象匿名”)]
说明:
1.编写在属性或setter上面,表示将Bean对象匿名对应的对象赋给该属性
2.name属性值为Bean对象匿名,表示将Bean对象匿名对应的对象赋给该属性
3.@Resource标注在setter上或不设置name属性,则name属性值默认为属性名
4.若未设置name属性,并且按照默认名称仍然找不到依赖对象时,@Resource将会按属性类型查找同类型的bean对象,然后注入到属性中.

方式4: P命名空间

Java类:
提供属性的setter和getter方法,无需其他操作.
在这里插入图片描述

配置文件:

第1步: 添加命名空间
xmlns:p=“http://www.springframework.org/schema/p”
在这里插入图片描述
第2步: 注册bean,并注入数据
<bean id=“bean匿名” class=“类全名” p:属性名/属性名-ref=“值/匿名” />
在这里插入图片描述

四.使用注解实现SpringAOP

面向切面编程:

面向切面编程[Aspect Oriented Programming,简称AOP]指在运行时,动态的将代码切入到类的指定方法或位置上的编程思想.

术语:
  • aspect(切面): 指横切性关注点的抽象即为切面,它与类相似,类是对物体特征的抽象.[通俗讲,切面是定义了额外功能的类].
  • joinpoint(连接点): 指被拦截的点,分为属性,方法,构造器.Spring只支持方法类型的连接点.[通俗讲,应用额外功能的地方称为连接点]
  • pointcut(切入点): 指对"连接点"进行拦截的定义.[通俗讲,控制"哪些地方"应用切面]
  • advice(通知): 指拦截到"连接点"之后所要做的事情.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知.
  • target(目标对象): 指要使用切面的类.
  • weave(织入): 指将"切面"应用到"目标对象"并导致"代理对象"创建的过程称为织入.
  • introduction(引入): 在不修改类代码的前提下,Introduction可以在运行期为类动态地添加一些方法或Field.
通知类型:
前置通知: 在目标方法执行之前,执行前置通知
后置通知: 在目标方法执行之后,执行后置通知
异常通知: 在目标方法执行并抛出异常时,执行异常通知
最终通知: 在目标方法执行之后或抛出异常时,执行最终通知
环绕通知: 在前置通知和目标方法之前,以及最终通知之前执行环绕通知
AOP通知执行过程

在这里插入图片描述
在这里插入图片描述

实现AOP方式

Spring提供了多种方式实现AOP,常用:(JDK动态代理和CGLIB代理)

方式一JDK动态代理:

使用Proxy类创建代理对象,含有处理类必须实现InvocationHandler接口.目标类必须实现接口[不限制类型],JDK动态代理通过实现目标类实现的所有接口,实现动态代理功能

方式二CGLIB代理:

使用Enhancer类生成代理对象,含有处理类必须实现MethodInterceptor接口.CGLIB通过生成目标类的子类,并重写目标类非final的方法实现动态代理功能

代理方式选择:
1.默认情况下,目标对象[被拦截的对象]必须实现了接口,Spring才会使用JDK动态代理.否则,Spring自动使用CGLIB代理
2.当目标对象实现了接口,可以设置aop:aspectj-autoproxy的proxy-target-class为true,强制使用CGLIB代理

使用注解方式实现AOP开发步骤:
第1步: 添加jar包

Spring基本jar+AOP相关jar

第2步:编写切面类,设置切入点和通知
  • @Aspect: 编写在类声明上面,表示声明当前类为切面类
  • @Pointcut: 编写在方法上面,定义切入点要求,"方法名()"即为切入点名
    格式:@Pointcut(value = “execution(表达式)”)

表达式:
execution(返回值类型 目录.类名.方法名(参数类型,…) && args(参数名,参数名,…))
说明:
1.返回值类型为void或类型全名,可配合"!“使用.[!void表示有返回值]
2.任意返回值/任意类名/任意方法名,都可以用”“表示.
3.若包含指定目录的任意子目录,用”.“表示
4.参数类型为类全名.任意个数和类型用”…"表示
5.args()表示必须有指定个数的参数
示例：@Pointcut(value = "execution( service.UserService.*(…))")

  • @Before :编写在方法上面，鄙视声明当前方法为前置通知
    格式: @Before(value=“切入点名”,argNames=“参名,…”)
  • @AfterReturning: 编写在方法上面,表示声明当前方法为后置通知
    格式: @AfterReturning(value=“切入点名”,return=“参数名[接收返回值]”)
  • @After: 编写在方法上面,表示声明当前方法为最终通知
    格式: @After(value=“切入点名”)
  • @AfterThrowing: 编写在方法上面,表示声明当前方法为例外通知
    格式: @AfterThrowing(value=“切入点名”,throwing=“参数名[接收异常对象]”)
  • @Around: 编写在方法上面,表示声明当前方法为环绕通知
    格式: @Around(value=“切入点名”)

说明:
public Object 环绕通知(ProceedingJoinPoint point){
Object rs=point.proceed();//继续执行下1个通知或调用目标方法
return rs; //必须返回,否则后置通知无法获得目标方法返回值
}

定义切面类 在切面类中切入点上说明拦截目标 实现动态添加
@Component
@Aspect    //声明当前类为切入类 切入类包含额外的方法
public class AOP {
    //定义一个切入点 
    @Pointcut(value = "execution(* service.UserService.*(..))")
    public void test(){
        System.out.println("定义切入点：切入点为被标注的方法的名称");
    }
    //定义前置通知[用来拦截方法的参数]
    @Before(value = "test() && args(p1) ",argNames = "p1")
    public  void qianzhitongzhi(Object p1){
        System.out.println("前置通知");
        System.out.println("拦截的方法参数"+p1);
    }

    //定义后置通知[用来拦截方法的返回值]
    @AfterReturning(value = "test()",returning = "returnDate")
    public void houzhitongzhi(Object returnDate){
        System.out.println("后置通知");
        System.out.println("被拦截的方法的返回值为"+returnDate);
    }

    @After("test()")
    public void zuizhongtongzhi(){
        System.out.println("最终通知");
    }

    //定义异常通知[用来拦截异常和打印异常信息]
    @AfterThrowing(value = "test()",throwing = "e")
    public void  yichangtongzhi(Exception e){
        System.out.println("异常通知");
        System.out.println(e.getMessage());

    }

    //环绕通知
    @Around("test()")
    public  Object huanraotongzhi(ProceedingJoinPoint point ) throws Throwable {
        System.out.println("进入环绕通知");
        Object ob = point.proceed();
        System.out.println("离开环绕通知");
        return  ob;
    }
}

注意: @Before,@AfterReturning,@After,@AfterThrowing,@Aroud默认属性为value[切入点名]

第3步: 开启aspectj自动代理,并注册切面类
<context:component-scan base-package="bean,service,aop"/<!--开启自动扫描并将有注释的类自动注册-->
<aop:aspectj-autoproxy/><!--启动AspectJ自动代理功能-->

在这里插入图片描述

第4步: 注册AOP
    <!--注册切面类-->
    <bean id="myaop" class="aop.MyAOP" />
    或
    @Component <!--若使用注释即可自动注册该类-->
第5步: 正常编写程序,测试AOP效果

在这里插入图片描述

使用XML方式实现AOP

步骤:

第1步: 添加jar包

同annotation方式

第2步: 编写切面类

同annotation方式,但是移除所有的注解[在配置文件中实现注解的功能].

/*@Component*/
@Aspect    /*声明当前类为切入类 切入类包含额外的方法*/
public class AOP1 {

    @Pointcut(value = "execution(* service.UserService.*(..))")
    public void test(){
        System.out.println("定义切入点：切入点为被标注的方法的名称");
    }
    
    @Before("test()")
    public  void qianzhitongzhi(){
        System.out.println("前置通知");
    }

    @AfterReturning("test()")
    public void houzhitongzhi(){
        System.out.println("后置通知");
    }

    @After("test()")
    public void zuizhongtongzhi(){
        System.out.println("最终通知");
    }


    @AfterThrowing("test()")
    public void  yichangtongzhi(){
        System.out.println("异常通知");
    }

    //环绕通知-
    @Around("test()")
    public  Object huanraotongzhi(ProceedingJoinPoint point ) throws Throwable {
        System.out.println("进入环绕通知");
        Object ob = point.proceed();
        System.out.println("离开环绕通知");
        return  ob;
    }
}
第3步: 编写Spring配置文件

a.将切面类交给Spring管理
b.配置面向切面

<!--开启自动扫描-->
<context:component-scan base-package="bean,service,aop"/>
<aop:config>
	<!--定义1个切面类-->
	<aop:aspect id="myaop" ref="myAOP">
		<!--定义1个切入点拦截service.UserService类中的所有方法(有参无参)-->
		<aop:pointcut id="mycut" expression="execution(* service.UserService.*(..))"/>
		<!--定义通知-->
		<aop:before method="beforeDeal" pointcut-ref="mycut" arg-names="joinPoint" />
		<aop:after-returning method="afterReturningDeal" pointcut-ref="mycut" returning="returnData"/>
		<aop:after method="afterDeal" pointcut-ref="mycut" />
		<aop:after-throwing method="afterThrowingDeal" pointcut-ref="mycut" throwing="e"/>
		<aop:around method="aroundDeal" pointcut-ref="mycut" />
	</aop:aspect>
</aop:config>
第4步: 编写程序,测试

同annotation方式

mybatis与spring框架整合

框架的作用:

MyBatis: 用于替代JDBC,用于数据持久化
Spring: 用于整合框架,提供整合功能及其他功能[IoC,DI,AOP,事务管理等等]
SpringMVC: 用于替代JSP,用于处理请求和响应[SpringMVC属于Spring的一部分]

Spring整合MyBatis:

MyBatis功能/操作: 配置文件[实体类别名,数据源,映射文件等等],映射文件[业务标签],MyBatis代码[SqlSessionFactory,SqlSession等对象操作]
Spring功能/操作: IoC,DI,AOP,事务管理

整合目标:

  • 用Spring来替代MyBatis中的数据源,提供SqlSessionFactory,SqlSession等对象,管理事务
  • .MyBatis整合中要做的内容: 配置文件[保留 实体类别名,映射文件等等],映射文件[业务标签]无变化,MyBatis代码[业务代码]

整合步骤:

第1步: 整合jar包
  1. MyBatis相关jar包:
    mybatis-3.5.1.jar
    log4j-1.2.17.jar
  2. 数据库驱动器:
    mysql-connector-java-5.1.22-bin.jar
  3. Spring相关jar:
    commons-logging-1.2.jar
    spring-aop-5.1.2.RELEASE.jar
    spring-beans-5.1.2.RELEASE.jar
    spring-context-5.1.2.RELEASE.jar
    spring-core-5.1.2.RELEASE.jar
    spring-expression-5.1.2.RELEASE.jar
  4. spring-jdbc-5.1.2.RELEASE.jar
    spring-tx-5.1.2.RELEASE.jar
  5. aopalliance-.jar
    aspectjrt.jar
    aspectjweaver.jar
    cglib-nodep-2.1_3.jar
  6. 额外jar:
    连接池: commons-dbcp-1.4.jar,commons-pool-1.6.jar
    MyBatis与Spring整合: mybatis-spring-2.0.3.jar
第2步: 整合配置文件

MyBatis配置文件:
mybatis-conf.xml[实体类别名,环境(数据源),加载映射],
log4j.xml[控制日志输出],映射文件[业务标签]
Spring配置文件: application.xml[控制反转]

整合后:
MyBatis配置文件中: 去掉环境配置(数据源),实体类别名,加载映射
整合后mybatis-config.xml文件中的内容

log4j.xml[控制日志输出]: 无需操作
映射文件[业务标签]: 无需操作、
Spring配置文件中: 添加数据源,提供SqlSessionFactory,提供事务管理
1.开启自动扫描: 扫描service,action,mapper等等,实现控制反转[管理相关对象]---->注解方式实现控制反转
2.提供数据源
3.提供SqlSessionFactoryBean
4.提供事务管理 @@Transactional标注的类中所有关于数据库操作时,自动提交事务,以及回滚事务
5.注册其他必须的对象
Spring配置文件中的内容

第3步: 整合代码

MyBatis代码正常编写即可,若需要SqlSessionFactory对象可以从Spring容器中获得.

Mapper方式实现CURD:
1.Mapper接口: 正常编写
2.业务类: 声明Mapper接口类型的属性,并由Spring注入属性值
3.注册Mapper接口:

 方式1: 指定加载某个1个Mapper接口
      <bean class="org.mybatis.spring.mapper.MapperFactoryBean" id="mapperFactoryBean">
      <property name="sqlSessionFactory" ref="factory" />
      <property name="mapperInterface" value="mapper.UserMapper" />
      </bean>
    方式2: 指定加载某个包中的所有Mapper接口
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" id="mapperScannerConfigurer" >
    <property name="sqlSessionFactoryBeanName" value="factory" />
    <property name="basePackage" value="mapper" />
    </bean>
慵ノ懒
关注
专栏目录
Spring Boot 第一个示例 “main” 方法
Feng_clay的博客
12-07 1179
示例程序的最后需要介绍方法就是main方法. 针对一个应用程序，这个方法是标准的方法。在 Java 环境中，是需要使用 Main 方法来执行的。 在我们定义的这个 main 方法中有一行代码，这个代码就是被用来运行 Spring Boot 的SpringApplication类中的run。通过这个 run，我们就可以运行 Spring Boot 应用了。SpringApplication将会引导我们的应用完成一系列的功能，包括有启动 Spring，开始自动配置 Tomcat Web 应用服务...
第6章 初识Spring框架
小猪宝宝的博客
08-30 2410
本章主要讲解了Spring框架的基础知识，首先介绍了Spring框架基础知识，包括了Spring概述、Spring框架的优点、Spring框架的体系结构、Spring 5的新特性和Spring下载及目录结构；然后编写了Spring的入门程序；最后讲解了控制反转与依赖注入，包括控制反转的概念、依赖注入的概念、依赖注入的类型和依赖注入的应用。通过本章的学习，读者可以对Spring框架的基础有个大致的了解，为框架开发打下坚实基础。 ...
使用main方法启动spring程序
二师兄想吃肉的博客
09-23 3859
在 spring 框架中，由于对象都交给了 IoC 容器进行管理，那么直接在 main 方法中创建 service 层对象，就会出现空指针异常（NPE）。正确的方式是从 IoC 的容器中取出对象，再使用对象中的方法或者属性就可以了。
Spring通过main方法启动
技术摸索和实践者
03-24 3114
文章目录Spring ApplicationContext 容器完整示例（Spring实战4第一章节源码扩展学习） 一直以来都是使用Web工程，编写Service、Controller，启动tomcat服务，然后采用HTTP方式访问方法。以为Spring必须在web工程下才能使用（这个定性思维很要命，尴尬得很）。然后遇到一个需求我想编写一个批量导出程序不需要在tomcat里跑，然后一直在琢磨是否可...
spring main projects
wjandy0211的博客
05-22 505
1. spring framework核心支持依赖注入，事务管理，Web应用程序，数据访问，消息传递，测试等等。特征核心技术：依赖注入，事件，资源，i18n，验证，数据绑定，类型转换，SpEL，AOP。测试：模拟对象，TestContext框架，Spring MVC测试，WebTestClient。数据访问：事务，DAO支持，JDBC，ORM，编组XML。Spring MVC和Spring We...
spring框架初识
傲雪专栏
09-27 2925
spring是一个分层框架，共有七部分组成，这个七了部分有式独立存在的，他们分别是： 1.核心容器：核心容器是提供框架的基本功能，它的主要组件是BeanFactory，它是工厂模式的实现 2.spring上下文：spring的上下文是一个配置文件，向spring提供上下文的信
Spring基础框架 一 入门
小菜鸡的博客
07-30 736
Spring 入门 第一天
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第五天
最新发布
10-29
Spring框架，作为2003年崛起的一款轻量级JAVAEE框架，以其简洁和强大的功能深受开发者喜爱。本篇将主要探讨Spring框架的几个核心知识点，包括事务传播属性、注解式事务管理、注解式开发、SSM（Spring+SpringMVC+...
第10章 初识Spring MVC框架
小猪宝宝的博客
09-01 1434
本章主要对Spring MVC的基础知识进行了整体介绍。首先对Spring MVC框架进行了简单的介绍；然后讲解了一个Spring MVC入门程序的编写；最后通过入门程序对Spring MVC的工作原理进行了详细讲解。
Spring本地启动Main函数-AnnotationConfigApplicationContext
z69183787的专栏
04-05 1142
spring
main方法启动spring
weixin_30675247的博客
04-29 798
main方式读取spring配置、main方法启动spring/ 有时候只想写一下简单的测试用一下、 新建一个maven项目 依赖pom <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="htt...
第五章 Spring核心概念
08-31 178
5.1.1 企业级应用开发 企业级应用是指那些为商业组织，大型企业而创建部署的解决方案及应用，大型企业级应用的结构复杂，涉及的外部资源众多，事务密集，数据规模大，用户数量多，有较强的安全性考虑和较高的性能要求 Spring是企业应用开发的 一站式 选择 Spring贯穿表现层，业务层，持久层。 5.1.2 Spring的 绿草丛 Spring是一个轻量级框架，...
Java入门（十）Spring框架 Mybatis框架 Ajax
ACGkaka的博客
12-07 569
目录一、Spring简介、Spring容器二、Spring IOC、参数值注入三、基于注解的组件扫描、SpringMVC、五大组件四、SpringMVC应用五、系统分层、登录案例六、中文乱码处理、拦截器、Spring处理异常七、SpringJDBC、Mybatis八、Mybatis基本应用、Mapper映射器、Spring Mybatis（方式一）九、Spring MyBatis（方式二）十、AJAX简介十一、AJAX编码问题、缓存问题、JSON十二、JQuery对ajax的支持、load方法 ????：哈
SpringBoot main方法分析
qq_46337496的博客
02-16 2179
Spring整合MyBatis 在了解SpringBoot的main方法之前，先看一下Spring整合Mybatis的例子，首先对于Spring整合Mybatis，对于Spring的配置文件可以通过 .xml 或 配置类 的形式，这里不做详细介绍。 项目结构 Spring的main方法 public class Test { public static void main(String[] args) throws Exception { ApplicationContext context =
《第五章【拓展进阶（上）】框架源码》之《第二节 Mybatis框架原理》
qq_23204557的博客
10-29 142
《5.2.1 MyBatis简介和优势》24分左右：Mybatis与Hibernate的区别 Mybatis Hibernate 轻量级 重量级 半自动 自动 《5.2.2 手写MyBatis》 20:51, 87分: MyBatis中的动态代理 72分：
在单独的main方法中运行spring 管理的类方法
chonggongguan4517的博客
05-05 335
import org.apache.commons.lang3.RandomStringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.context.supp...
Spring—学习笔记#day02
安藤青司的博客
07-29 1512
目录 1、环境搭建 第一步：在基于注解的配置中，我们还要多拷贝一个 aop 的 jar 包 第二步：使用@Component 注解配置管理的资源 第三步：创建 spring的 xml 配置文件并开启对注解的支持 2、spring中ioc的常用注解 2.1用于创建对象的 2.1.1@Component 2.1.2@Controller @Service @Repository ...
spring中使用main方法进行调试
总有一天，你的日积月累，会成为别人的望尘莫及
11-09 3867
先交代一下具体情况： 1、项目用的SSH 2、使用main方法进行测试的action有注入execSQL、Table5DAO、Table6DAO、Table7DAO、Table8DAO五个bean，第一个bean又注入了其他的bean，后面四个是单独的。   然后上代码： public static void main(String[] args) throws Exception ...
精通Spring框架：基础与实战
书中分为两部分，第一部分介绍了Spring框架的基础知识，包括创建第一个Spring应用、处理类和依赖、应用不同配置、使用Bean作用域、操作集合和自定义类型、使用资源文件以及测试Spring应用等内容。第二部分则深入到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值