Spring相关原理

最新推荐文章于 2021-02-27 11:47:35 发布
最新推荐文章于 2021-02-27 11:47:35 发布
阅读量171 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liuzhenqing1/article/details/100006603
版权

Spring第一天
1.什么是Spring :

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

2.EE开发分成三层结构:

  • WEB层:Spring MVC.
  • 业务层:Bean管理:(IOC)
  • 持久层:Spring的JDBC模板.ORM模板用于整合其他的持久层框架.

Expert One-to-One J2EE Design and Development :J2EE的设计和开发:(2002.EJB)
Expert One-to-One J2EE Development without EJB :J2EE不使用EJB的开发.
3.为什么学习Spring:
方便解耦，简化开发
Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理
AOP编程的支持
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无需手动编程
方便程序的测试
Spring对Junit4支持，可以通过注解方便的测试Spring程序
方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
降低JavaEE API的使用难度
Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低
Spring的版本:
Spring 3.X 和 Spring4.X

4.Spring的入门案例:(IOC)
IOC的底层实现原理

IOC：Inversion of Control 控制反转. 指的是 对象的创建权反转(交给)给Spring.
作用是实现了程序的解耦合.
步骤一:下载Spring的开发包:
官网：http://spring.io/
下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring解压:(Spring目录结构:)

  • docs :API和开发规范.
  • libs :jar包和源码.
  • schema :约束.
    步骤二:创建web项目,引入Spring的开发包:

步骤三:引入相关配置文件:
log4j.properties
applicationContext.xml
引入约束:
spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

步骤四:编写相关的类: public interface UserDao { 
public void sayHello();

}

public class UserDaoImpl implements UserDao {

@Override
public void sayHello() {
	System.out.println("Hello Spring...");
}

}
步骤五:完成配置：

步骤六:编写测试程序:
@Test
// Spring的方式：
public void demo2(){
// 创建Spring的工厂类：
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“applicationContext.xml”);
// 通过工厂解析XML获取Bean的实例.
UserDao userDao = (UserDao) applicationContext.getBean(“userDao”);
userDao.sayHello();
}
IOC和DI:
IOC :控制反转,将对象的创建权交给了Spring.
DI :Dependency Injection 依赖注入.需要有IOC的环境,Spring创建这个类的过程中,Spring将类的依赖的属性设置进去.

Spring中的工厂:
ApplicationContext:
ApplicatioContext接口有两个实现类:

ClassPathXmlApplicationContext :加载类路径下Spring的配置文件.
FileSystemXmlApplicationContext :加载本地磁盘下Spring的配置文件.
BeanFactory:

了解：BeanFactory和ApplicationContext的区别:
BeanFactory :是在getBean的时候才会生成类的实例.
ApplicationContext :在加载applicationContext.xml时候就会创建.
了解：配置STS的XML的提示:
Spring配置文件中提示的配置
复制路径:

  • http://www.springframework.org/schema/beans/spring-beans.xsd
    查找XML Catalog:

点击Add…

5.Spring的相关配置
id属性和name属性标签的配置
id :Bean起个名字. 在约束中采用ID的约束:唯一. 必须以字母开始，可以使用字母、数字、连字符、下划线、句话、冒号 id:不能出现特殊字符.
了解：name属性
name:Bean起个名字. 没有采用ID的约束. name:出现特殊字符.如果没有id的话 , name可以当做id使用.
整合struts1的时候:

scope属性：Bean的作用范围.

  • singleton :默认值，单例的.
  • prototype :多例的.
  • request :WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中.
  • session :WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中.
  • globalSession :WEB项目中,应用在Porlet环境.如果没有Porlet环境那么globalSession相当于session.
    了解：Bean的生命周期的配置:
    通过配置标签上的init-method作为Bean的初始化的时候执行的方法，配置destroy-method作为Bean的销毁的时候执行的方法。
    销毁方法想要执行，需要是单例创建的Bean而且在工厂关闭的时候，Bean才会被销毁.
    6.Spring的Bean的属性注入
    了解：构造方法的方式注入属性
    set方法的方式注入属性

Spring的属性注入：对象类型的注入:



注入复杂类型:

		<bean id="person" class="com.clive.demo3.Person">
	<!-- 数组类型的属性 -->
		<property name="addr">
			<list>
				<value>会希</value>
				<value>冠希</value>
				<value>天一</value>
			</list>
		</property>
	
		<!-- 注入List集合的数据 -->
		<property name="list">
			<list>
				<value>芙蓉</value>
				<value>如花</value>
				<value>凤姐</value>
			</list>
		</property>
	
		<!-- 注入Map集合 -->
		<property name="map">
			<map>
				<entry key="aaa" value="111"/>
				<entry key="bbb" value="222"/>
				<entry key="ccc" value="333"/>
			</map>
		</property>
	
		<!-- Properties的注入 -->
		<property name="properties">
			<props>
				<prop key="username">root</prop>
				<prop key="password">123</prop>
			</props>
		</property>
	</bean>

7.Spring与web整合问题

**** 每次请求都会创建一个工厂类,服务器端的资源就浪费了,一般情况下一个工程只有一个Spring的工厂类就OK了.
* 将工厂在服务器启动的时候创建好,将这个工厂放入到ServletContext域中.每次获取工厂从ServletContext域中进行获取.
* ServletContextLinstener :监听ServletContext对象的创建和销毁.

Spring第二天
1.Spring注解
1.1在Spring的注解的AOP中需要引入spring-aop的jar包。
步骤三:引入相关配置文件:
log4j.properties
applicationContext.xml
1.2引入约束:
spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

  • 引入约束:(引入context的约束):
1.3:编写相关的类: public interface UserDao { 
public void sayHello();

}

public class UserDaoImpl implements UserDao {

@Override
public void sayHello() {
	System.out.println("Hello Spring...");
}

}
1.4:配置注解扫描

<context:component-scan base-package="com.clive.demo1"/>

在相关的类上添加注解:
@Component(value=“userDao”)
public class UserDaoImpl implements UserDao {

@Override
public void sayHello() {
	System.out.println("Hello Spring Annotation...");
}

}
1.5编写测试类:
@Test
public void demo2() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
“applicationContext.xml”);
UserDao userDao = (UserDao) applicationContext.getBean(“userDao”);
userDao.sayHello();
}

1.6Spring的Bean管理的中常用的注解
@Component:组件.(作用在类上)
Spring中提供@Component的三个衍生注解:(功能目前来讲是一致的)

  • @Controller :WEB层
  • @Service :业务层
  • @Repository :持久层

这三个注解是为了让标注类本身的用途清晰，Spring在后续版本会对其增强
属性注入的注解:(使用注解注入的方式,可以不用提供set方法.)
@Value :用于注入普通类型.
@Autowired :自动装配:

  • 默认按类型进行装配.
  • 按名称注入:
  • @Qualifier:强制使用名称注入.
    @Resource相当于:
  • @Autowired和@Qualifier一起使用.
    Bean的作用范围的注解:
    @Scope:
  • singleton:单例
  • prototype:多例
    Bean的生命周期的配置:
    @PostConstruct :相当于init-method
    @PreDestroy :相当于destroy-method
    Spring的Bean管理的方式的比较:

XML和注解:

  • XML :结构清晰.
  • 注解 :开发方便.(属性注入.)

实际开发中还有一种XML和注解整合开发:

  • Bean有XML配置.但是使用的属性使用注解注入.

2.AOP的概述
2.1什么是AOP

Spring是解决实际开发中的一些问题:

  • AOP解决OOP中遇到的一些问题.是OOP的延续和扩展.
    2.2为什么学习AOP
    对程序进行增强:不修改源码的情况下.
  • AOP可以进行权限校验,日志记录,性能监控,事务控制.
    Spring的AOP的由来:
    AOP最早由AOP联盟的组织提出的,制定了一套规范.Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范.
    2.3底层实现:动态代理机制
  • Spring的AOP的底层用到两种代理机制：
    • JDK的动态代理 :针对实现了接口的类产生代理.
    • Cglib的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术 生成当前类的子类对象.

2.4Spring底层AOP的实现原理:（了解）
JDK动态代理增强一个类中方法:
public class MyJDKProxy implements InvocationHandler {

private UserDao userDao;

public MyJDKProxy(UserDao userDao) {
	this.userDao = userDao;
}

// 编写工具方法：生成代理：
public UserDao createProxy(){
	UserDao userDaoProxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
			userDao.getClass().getInterfaces(), this);

	return userDaoProxy;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	if("save".equals(method.getName())){
		System.out.println("权限校验================");
	}
	return method.invoke(userDao, args);
}

}
Cglib动态代理增强一个类中的方法:
public class MyCglibProxy implements MethodInterceptor{

private CustomerDao customerDao;

public MyCglibProxy(CustomerDao customerDao){
	this.customerDao = customerDao;
}

// 生成代理的方法:
public CustomerDao createProxy(){
	// 创建Cglib的核心类:
	Enhancer enhancer = new Enhancer();
	// 设置父类:
	enhancer.setSuperclass(CustomerDao.class);
	// 设置回调:
	enhancer.setCallback(this);
	// 生成代理：
	CustomerDao customerDaoProxy = (CustomerDao) enhancer.create();
	return customerDaoProxy;
}

@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
	if("delete".equals(method.getName())){
		Object obj = methodProxy.invokeSuper(proxy, args);
		System.out.println("日志记录================");
		return obj;
	}
	
	return methodProxy.invokeSuper(proxy, args);
}

}

Spring的基于AspectJ的AOP开发
3.AOP的开发中的相关术语
Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
Target(目标对象):代理的目标对象
Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入
Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
Aspect(切面): 是切入点和通知（引介）的结合
4.Spring使用AspectJ进行AOP的开发：XML的方式（*****）
4.1引入相应的jar包

  • spring的传统AOP的开发的包
    spring-aop-4.2.4.RELEASE.jar
    com.springsource.org.aopalliance-1.0.0.jar
  • aspectJ的开发包:
    com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
    spring-aspects-4.2.4.RELEASE.jar

4.2引入Spring的配置文件
引入AOP约束:

编写目标类 创建接口和类: public interface OrderDao { public void save(); public void update(); public void delete(); public void find(); }

public class OrderDaoImpl implements OrderDao {

@Override
public void save() {
	System.out.println("保存订单...");
}

@Override
public void update() {
	System.out.println("修改订单...");
}

@Override
public void delete() {
	System.out.println("删除订单...");
}

@Override
public void find() {
	System.out.println("查询订单...");
}

}
4.3目标类的配置

</bean>

4.4整合Junit单元测试(了解)
public class SpringDemo3 {
@Test
public void demo1(){
orderDao.save();
orderDao.update();
orderDao.delete();
orderDao.find();
}
}
4.5通知类型
前置通知 ：在目标方法执行之前执行.
后置通知 ：在目标方法执行之后执行
环绕通知 ：在目标方法执行前和执行后执行
异常抛出通知：在目标方法执行出现 异常的时候 执行
最终通知 ：无论目标方法是否出现异常 最终通知都会 执行.
4.6切入点表达式
execution(表达式)
表达式:
[方法访问修饰符] 方法返回值 包名.类名.方法名(方法的参数)

4.7编写一个切面类
public class MyAspectj {
// 前置增强
public void before(){
System.out.println(“前置增强===========”);
}
}
4.8配置完成增强

Spring第三天
1.aop注解
1.1导入约束文件

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

1.2导入jar包

1.3编写目标类:
public class ProductDao {
public void save(){
System.out.println(“保存商品…”);
}
public void update(){
System.out.println(“修改商品…”);
}
public void delete(){
System.out.println(“删除商品…”);
}
public void find(){
System.out.println(“查询商品…”);
}
}
1.4配置目标类：

1.5开启aop注解的自动代理:
aop:aspectj-autoproxy/
1.6AspectJ的AOP的注解:
@Aspect:定义切面类的注解

通知类型:
* @Before :前置通知
* @AfterReturing :后置通知
* @Around :环绕通知
* @After :最终通知

  • @AfterThrowing :异常抛出通知.
    * @Pointcut :定义切入点的注解

2.spring jdbc模板
2.1导入约束文件
和上面的代码一样。
2.2导入jar包
和上面的代码一样
2.3创建一个测试类:
@Test
// JDBC模板的基本使用：
public void demo1(){
DriverManagerDataSource dataSource = new DriverManagerDataSource();
//配置驱动 我用的mysql 还是oracle sqlserver2005 mangodb
dataSource.setDriverClassName(“com.mysql.jdbc.Driver”);
dataSource.setUrl(“jdbc:mysql://127.0.0.1/mysqldemo”);
dataSource.setUsername(“root”);
dataSource.setPassword(“root”);
JdbcTemplate template = new JdbcTemplate();
template.setDataSource(dataSource);
template.update(“INSERT INTO bank(username,money) values (?,?)”, “小美”,1000);
}
2.4在spring配置文件下完成

2.5编写测试类
2.6使用第三方连接池
	Dbcp连接池的使用：
		首先导入jar包
		 
		 
2.7 JDBC模板的CRUD的操作：
  1. 事务的回顾:
    3.1什么是事务:
    事务逻辑上的一组操作,组成这组操作的各个逻辑单元,要么一起成功,要么一起失败.
    3.2事务特性:
    原子性 :强调事务的不可分割.
    一致性 :事务的执行的前后数据的完整性保持一致.
    隔离性 :一个事务执行的过程中,不应该受到其他事务的干扰
    持久性 :事务一旦结束,数据就持久到数据库
    3.3如果不考虑隔离性引发安全性问题:
    脏读 :一个事务读到了另一个事务的未提交的数据
    不可重复读 :一个事务读到了另一个事务已经提交的update的数据导致多次查询结果不一致.
    虚读 :一个事务读到了另一个事务已经提交的insert的数据导致多次查询结果不一致.
    3.4解决读问题:设置事务隔离级别
    未提交读 :脏读，不可重复读，虚读都有可能发生
    已提交读 :避免脏读。但是不可重复读和虚读有可能发生
    可重复读 :避免脏读和不可重复读.但是虚读有可能发生.
    串行化的 :避免以上所有读问题.
    3.5Spring进行事务管理一组API
    3.6PlatformTransactionManager:平台事务管理器.
    ***** 真正管理事务的对象
    org.springframework.jdbc.datasource.DataSourceTransactionManager 使用Spring JDBC或iBatis 进行持久化数据时使用
    org.springframework.orm.hibernate3.HibernateTransactionManager 使用Hibernate版本进行持久化数据时使用

3.7TransactionDefinition:事务定义信息事务定义信息:

  • 隔离级别

  • 传播行为

  • 超时信息

  • 是否只读
    3.8TransactionStatus:事务的状态：记录事务的状态
    Spring的这组接口是如何进行事务管理：
    平台事务管理根据事务定义的信息进行事务的管理,事务管理的过程中产生一些状态,将这些状态记录到TransactionStatus里面
    3.9事务的传播行为
    PROPAGION_XXX :事务的传播行为

  • 保证同一个事务中
    PROPAGATION_REQUIRED 支持当前事务，如果不存在 就新建一个(默认)
    PROPAGATION_SUPPORTS 支持当前事务，如果不存在，就不使用事务
    PROPAGATION_MANDATORY 支持当前事务，如果不存在，抛出异常

  • 保证没有在同一个事务中
    PROPAGATION_REQUIRES_NEW 如果有事务存在，挂起当前事务，创建一个新的事务
    PROPAGATION_NOT_SUPPORTED 以非事务方式运行，如果有事务存在，挂起当前事务
    PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常

PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行
3.10编写测试类：

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



<aop:aspectj-autoproxy />






<!--  
因为我使用了JdbcDaoSupport 里面已经有jdbcTemplate对象了 所以不用了
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource" />
</bean>
-->

<bean id="userDao" class="com.clive.demo1.UserDaoImpl" />
<bean id="myAspectj" class="com.clive.demo1.MyAspectj" />
<bean id="bankDao" class="com.clive.demo3.BankDaoImpl">
	<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="bankService" class="com.clive.demo3.BankServiceImpl">
	<property name="bankDao" ref="bankDao"/>

</bean>
<!-- 
	申明式事务需要配置一个事务管理器
	他可以帮我管理事务
 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 
	配置事务的隔离级别和传播行为
 -->
<tx:advice id="transferdvice" transaction-manager="transactionManager">
	<tx:attributes>
		<tx:method name="out*" isolation="DEFAULT" />
		<tx:method name="in*" isolation="DEFAULT" />
	</tx:attributes>
</tx:advice>
<!--
	配置aop 告诉他我的切面和通知
	<aop:aspect ></aop:aspect>
	这种写法针对的是 不加事务的 只是配置 日志的  或者普通切面的
 -->
<aop:config>
	<!-- 
		申明式事务 需要单独配置切入点
	 -->
	<aop:pointcut expression="execution(* *..*.BankServiceImpl.transfer(..))" id="testService"/>
	<!-- 
		那个方法需要加入事务管理
	 -->
	<aop:advisor advice-ref="transferdvice" pointcut="testService"/>
</aop:config>
Liuzhenqing12
关注
Spring事务处理原理步骤详解
08-19
2. 环境搭建：导入相关依赖，例如数据源、数据库驱动、Spring-jdbc模块。 3. 配置数据源、JdbcTemplate（Spring提供的简化数据库操作的工具）。 4. 给方法上标注@Transactional，表示当前方法是一个事务方法。 5. @...
序号8、Spring原理讲解
Alan先生的代码屋
02-04 542
Spring原理讲解 1、什么是Spring框架，Spring框架主要包含哪些模块 ​ Spring是一个开源框架，Spring是一个轻量级的Java 开发框架。它是为了解决企业应用开发的复杂性而创建的。 框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。 Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从
Spring原理简介
微笑的博客
05-04 707
Spring简介 Spring的历史  Spring的基础架构起源于2000年早期，创始人为毕业于悉尼大学的音乐学博士RodJohnson。2003年2月，Spring架构正式成为开源项目，并发布于SourcesForge中。 Spring工作原理  Spring是一个轻量级的控制反转(IoC) 和面向切面(AOP)的容器框架。我们不需要通过ne关键词创建对象，而是在配置文件中配置JavaBean...
Spring 原理
qq_40896594的博客
09-15 3771
1、Spring 特点 1.1、轻量级 从大小和开销两方面而言 Spring 都是清轻量的。完整的 Spring 框架可以在一个大小只有 1M 多的 Jar 文件里发布，并且 Spring 所需的处理开销也是微不足道的。 此外，Spring 是非侵入式的：典型的 Spring 应用中的对象不依赖与 Spring 的特定的类。 1.2、控制反转 Spring 通过控制反转（IOC）技术促进了低耦合。 当应用了IOC，一个对象依赖的其他对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖。
聊聊什么是Spring以及其中的工作机制
qsxbzch的博客
03-22 4139
                              突然想复习下spring相关的笔记  许久没有用到Spring,聊之前呢,说说spring在javaee三层高架构里面起的作用,或者说可以起替代的作用,javaee中web层service层dao层分别对应springMvc,spring的ioc,spring的jdbcTemplate.  1.Spring是一个开源的轻量级框架,他的核心...
SpringCloud底层原理
01-27
一、业务场景介绍二、SpringCloud核心组件：Eureka三、SpringCloud核心组件：Feign四、SpringCloud核心组件：Ribbon五、SpringCloud核心组件：Hystrix六、SpringCloud核心组件：Zuul七、总结毫无疑问，SpringCloud是...
SpringCloud-Hystrix原理
02-24
Hystrix官网的原理介绍以及使用介绍非常详细，非常建议看一遍，地址见参考文档部分。1Hystrix能做什么通过hystrix可以解决雪崩效应问题，它提供了资源隔离、降级机制、融断、缓存等功能。资源隔离：包括线程池隔离和...
深入理解Spring事务原理
09-02
本文将深入探讨Spring事务原理，包括事务的基本概念、Spring事务的传播属性、数据库隔离级别以及事务的嵌套。 首先，事务的基本原理是基于数据库对事务的支持。在纯JDBC操作中，我们需要手动获取连接、开启和关闭...
详解Spring工作原理
weixin_51495453的博客
11-14 1万+
1、spring原理 内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射，反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的 。 Spring还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象 进行监督和控制（也就是 在调用这类对象的具体方法的前后去调用你指定的 模块）从而达到对一个模块扩充的功能。这些都是通过 配置类达到的。 Spring目的：
java风清扬简介_Spring 框架简介
weixin_33270404的博客
02-27 250
Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring 框架Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。图 1. Spring 框架...
Spring相关原理及应用
Sakura_xx的博客
09-08 301
Spring Spring通过DI(依赖注入)实现IOC(控制反转) spring的两种注入方式 构造方法注入 setter方法注入 spring的四种注入模型 注入模型：找Bean和设置Bean - no ---默认无自动装配，Bean引用必须由ref元素定义。 - byType ---按照该属性类型装配。 - byName ---按照名字装配，Spring寻找与需要自动装配的属性同名的bean。 - constructor ---推断构造方法，通过构造方法的参数去装配。 @Auto
spring工作原理
热门推荐
Xinghf
07-14 5万+
对spring原理曾经写过类似的博客，地址：点击打开链接。          可是经过一些时间后，虽然天天用着spring，但一提到原理方面，就遗忘了呢？就记得AOP和IOC，但是没有清楚的讲出来呢？ 思考了一下这个问题，总结如下。          1、对于美食的喜爱，以后学习技术的过程中，多和美食相关联，和忘不掉的那些相关联。          2、总是想着抓住最后一根稻草，却从来没有
Spring的基本原理
WangSir
06-28 5901
一：spring基本概念1）struts2是web框架，hibernate是orm框架2）spring是容器框架，创建bean，维护bean之间的关系3）spring可以管理web层，持久层，业务层，dao层，spring可以配置各个层的组件，并且维护各个层的关系二：spring核心原理1.IOC控制反转概念：控制权由对象本身转向容器，由容器根据配置文件创建对象实例并实现各个对象的依赖关系。核心：...
Spring的bean的生命周期
qq_34556139的博客
12-02 329
Spring的bean的生命周期 1.Spring 对bean进行实例化； 2.spring 将值和bean的引用注入到bean对应是属性中； 3.如果bean实现了BeanNameAware接口,Spring将bean的ID传递给setBeanName方法； … 如果这个Bean实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()，传递的是Spring工厂本...
Spring核心原理
ja.rome
10-18 1万+
Spring核心原理 在Spring中拥有许多的组件，但核心部分主要为：Beans、Core、Context、Expression，其中最为主要的为Core、与Beans，它们提供了最为核心的IOC和依赖注入功能。下文主要从这两个着手进行说明。 设计思想 Spring5架构图： Spring框架设计理念 在Spring框架中，其最核心组件应属Beans，Spring-Beans模块是所有应用...
Spring官网学习(一)概述
qq_36526036的博客
04-26 6044
文章目录1、Spring官网简介2、Spring总览2.1、什么是Spring2.2、Spring的发展历程3、Spring的设计理念4、Getting Started 1、Spring官网简介 进入Spring的官网介绍，可以看到，Spring官网将整个Spring框架分成如下8个部分： Overview：该模块主要介绍Spring的历史、设计理念、并且可以快速构建一个Spring的Demo等...
Spring面试底层原理的那些问题，你是不是真的懂Spring？
weixin_30663391的博客
06-25 2995
1、什么是 Spring 框架？Spring 框架有哪些主要模块？Spring 框架是一个为 Java 应用程序的开发提供了综合、广泛的基础性支持的 Java 平台。Spring帮助开发者解决了开发中基础性的问题，使得开发人员可以专注于应用程序的开发。Spring 框架本身亦是按照设计模式精心打造，这使得我们可以在开发环境中安心的集成 Spring 框架，不必担心 Spring 是如何在后台进行工...
Spring的基本原理-容器和bean
白骚的博客
07-13 1万+
  在Spring中，那些组成你应用程序的主体及由Spring Ioc容器所管理的对象，都被称之为bean。简单来讲，bean就是Spring容器的初始化、配置及管理的对象。除此之外，bean就与应用程序中的其他对象没有什么区别了。而bean定义以及bean相互间的依赖关系将通过配置元数据来描述。  容器：  org.springframework.beans.factory.BeanFactor...
Spring MVC原理详解：入门与配置
Spring MVC原理是一种基于模型-视图-控制器(Model-View-Controller, MVC)设计模式的轻量级Web应用框架，它由Spring框架提供并扩展了经典的MVC架构。Spring MVC的核心思想是将控制逻辑、数据处理和用户界面分离，使得...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值