学习Spring框架有这一篇就够了
目录
一.Spring框架
1.什么是Spring
2. 为什么使用spring
3.程序的耦合
4.解决办法IOC控制反转
二. 如何使用spring
1.Spring程序开发步骤
2.使用spring
(1) 引入jar包
(2)创建Spring的配置文件
(3) 创建一个接口类
(4)创建一个Dao类
(5) 使用ApplicationContext进行测试
3.BeanFactory和ApplicationContext的区别
(1) BeanFactory
(3) 面试题:BeanFactory和ApplicationContext区别
4.获取bean的方式
(1)通过bean.xml文件中bean标签的id的值获取bean(使用默认构造方法)
(2) 通过类型去获取
(3) 通过 id + 类型去获取
5.bean的作用范围
三.spring-DI依赖注入
1.什么是DI
2. DI依赖注入的类型有哪些
3.如何实现注入对象的属性值
(1)创建一个实体类:一定要提供set方法
(2) 在配置文件springmvc.xml中创建bean标签并赋值
4.自动注入
(1) 创建接口类
(2) 创建两个类并实现IUserDao接口
(3) 创建controller类，并引用接口
(4)在springmvc.xml中建立bean标签
(5) 建立测试类
5.使用注解完成IOC和DI功能
(1) 在springmvc中配置包扫描文件
(2) 创建controller
(3) dao接口和实现类
(4) 常见错误
一.Spring框架
1.什么是Spring
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架，简单来说， spring是一个轻量级开源的JAVAEE框架。
2. 为什么使用spring
1.方便解耦，便于开发（Spring就是一个大工厂，可以将所有对象的创建和依赖关系维护都交给spring管理）
2.spring支持aop编程（spring提供面向切面编程，可以很方便的实现对程序进行权限拦截和运行监控等功能）
3.声明式事务的支持（通过配置就完成对事务的支持，不需要手动编程）
4.方便程序的测试，spring 对junit4支持，可以通过注解方便的测试spring 程序
5.方便集成各种优秀的框架（）
6.降低javaEE API的使用难度（Spring 对javaEE开发中非常难用的一些API 例如JDBC,javaMail,远程调用等，都提供了封装，是这些API应用难度大大降低）
3.程序的耦合
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。
它有如下分类：
（1）内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
（2）公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
（3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
（4） 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。
（5）标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。
（6） 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。
（7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。
总结：耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。
内聚与耦合：内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。
4.解决办法IOC控制反转
控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
使用对象的时候不再是我们直接new对象，而是将创建对象的权利交给框架中的核心容器IOC，需要使用对象的时候直接从容器中获取
IoC的思想早就出现了，但是没有一个具体的实现，大家都是各自根据这个思想去写代码(自己去创建工厂)。后来有一个大师 Rod Johnson（Spring Framework创始人，著名作者。 Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。），写了一个框架，将IoC思想具体的实现了，这个框架后来起了个名字叫做 Spring。（因为在这之前 大家都是用hibernate这个框架，这个框架中文名字叫做冬眠，并且这个框架比较笨重，耦合比较高。Rod Johnson写的框架就是用来解决类似于hibernate高耦合的问题 ，所以他将自己框架的名字命名为 Spring 告诉全世界 冬天过去了 春天来了）
二. 如何使用spring
1.Spring程序开发步骤
2.使用spring
(1) 引入jar包
<dependencies><dependency><!-- 引入spring框架的jar包--><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.2.15.RELEASE</version></dependency></dependencies>(2)创建Spring的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!--表示一个类交于spring容器来创建id:bean的唯一标识。class: 类的全路径--><bean id="usDo" class="com.wt.entity03.UserDao" ></bean><bean id="usDo2" class="com.wt.entity03.UserDao02" scope="prototype"></bean><bean id="people" class="com.wt.entity03.People"></bean>
</beans>(3) 创建一个接口类
public interface IUserDao {public void show();
}(4)创建一个Dao类
public class UserDao implements IUserDao{public void show(){System.out.println("####################");}
}
(5) 使用ApplicationContext进行测试
public class Test01 {public static void main(String[] args) {//读取spring配置文件ApplicationContext app = new ClassPathXmlApplicationContext("springmvc.xml");通过唯一id获取bean对象IUserDao usDo = (IUserDao) app.getBean("usDo");System.out.println(usDo);usDo.show();}
}
3.BeanFactory和ApplicationContext的区别
(1) BeanFactory
Spring容器顶层接口：获取Bean对象;管理类和类之间的关系(依赖关系)BeanFactory由org.springframework.beans.factory.BeanFactory接口定义 BeanFactory是工厂模式（Factory pattern）的实现，是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖
BeanFactory接口下的基本方法：
containsBean(String beanName) 判断工厂中是否包含给定名称的bean定义，若有则返回true。
Object getBean(String str) 返回给定名称注册的bean实例。根据bean的配置情况，如果是singleton模式将返回一个共享实例，否则将返回一个新建的实例，如果没有找到指定bean,该方法可能会抛出异常。
Object getBean(String, Class) 返回以给定名称注册的bean实例，并转换为给定class类型
Class getType(String name) 返回给定名称的bean的Class,如果没有找到指定的bean实例，则排除NoSuchBeanDefinitionException异常
boolean isSingleton(String) 判断给定名称的bean定义是否为单例模式
String[] getAliases(String name) 返回给定bean名称的所有别名
public class Test02 {public static void main(String[] args) {//读取配置文件ClassPathResource resource = new ClassPathResource("springmvc.xml");//解析配置文件XmlBeanFactory factory = new XmlBeanFactory(resource);//当你使用哪个备案对象时，他才会帮你调用相应地构造函数拿到哪个bean时才会调用构造函数创建该bean.Object usDo = factory.getBean("usDo");Object people = factory.getBean("people");}}
(2) ApplicationContext接口
是基于BeanFactory之上的，提供了应用程序框架服务，扩展的新功能如下：提供国际化的支持资源访问，如URL和文件 事件传递载入多个配置文件等 实现类常见有三个
ClassPathXmlApplicationContext：-classpath路径加载xml文件的
FileSystemXmlApplicationContext：基于项目根路径进行加载xml文件的
AnnotationConfigApplicationContext：基于注解的配置。基于类书写的配置
public class Test02 {public static void main(String[] args) {//ApplicationContext 当你解析配置文件时，他就帮你调用所有的bean对应的构造函数//在加载spring容器时，spring会把配置文件中所有的bean创建好ApplicationContext app = new ClassPathXmlApplicationContext("springmvc.xml");IUserDao usDo = (IUserDao) app.getBean("usDo");usDo.show();}
}(3) 面试题:BeanFactory和ApplicationContext区别
BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
单例模式下创建对象的时间点不一样：
ApplicationContext：(饿汉模式)只要一读取配置文件，马上就会创建配置文件中配置的对象。
BeanFactory：(懒汉模式)什么时候getBean("id")，也就是说当根据id获取对象时，才会创建。
4.获取bean的方式
(1)通过bean.xml文件中bean标签的id的值获取bean(使用默认构造方法)
public class Test03 {public static void main(String[] args) {ApplicationContext app = new ClassPathXmlApplicationContext("springmvc.xml");//通过id获取bean对象IUserDao usDo = (IUserDao) app.getBean("usDo");}
}(2) 通过类型去获取
确保bean的类型是唯一的 不然会报错：
public class Test03 {public static void main(String[] args) {ApplicationContext app = new ClassPathXmlApplicationContext("springmvc.xml");//通过类型获取bean对象IUserDao bean = app.getBean(IUserDao.class);bean.show();}
}(3) 通过 id + 类型去获取
public class Test03 {public static void main(String[] args) {ApplicationContext app = new ClassPathXmlApplicationContext("springmvc.xml");//通过两者结合获取bean对象IUserDao usDo2 = app.getBean("usDo2", IUserDao.class);IUserDao usDo = app.getBean("usDo", IUserDao.class);usDo.show();usDo2.show();}
}5.bean的作用范围
bean对象的作用范围调整需要配置scope属性，设置单例还是多例（只针对ApplicationContext接口来说，默认是单例的）
单例:---无论创建多少次对象 他们始终指向同一个实例。
scope：常用 singleton,prototype
singleton：单例的（默认值）当加载配置文件时，就会创建对象。
prototype：多例的（当getBean时才会创建对象）
request：作用于请求范围---同一个那么使用bean同一个。
session：作用于会话范围---同一个会话
三.spring-DI依赖注入
1.什么是DI
DI：依赖注入，实现控制反转（IoC）的一种方式。控制反转即获取依赖的资源的方式反转了，使代码模块的耦合关系变弱。
2. DI依赖注入的类型有哪些
八种基本数据类型（byte,short,int,long,float,double,char,boolean）
字符串类型（String）
引用类型 (Claszz claszz--------------实体类)
集合类型(List,Map,Set...)
数组类型 (Integer[] sex)
3.如何实现注入对象的属性值
(1)创建一个实体类:一定要提供set方法
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="stu" class="com.wt.entity.Student">
<!-- 基本类型注入--><property name="name" value="阮籍" /><property name="age" value="23" />
<!-- 引用类型注入--><property name="claszz" ref="claszz" />
<!-- 向数组类型注入--><property name="sex"><array><value>1</value><value>0</value><value>2</value></array></property><!-- 集合类型注入--><property name="hobby"><list><value>看电影</value><value>追海报</value><value>吹牛皮</value></list></property><property name="set"><set><value>一二三</value><value>数星星</value><value>弹吉他</value></set></property><property name="map"><map><entry key="一" value="数羊"/><entry key="二" value="数鸡"/><entry key="三" value="数星星"/></map></property></bean>
<!-- 向实体类Claszzz注入值--><bean id="claszz" class="com.wt.entity.Claszz" ><property name="id" value="7" /><property name="name" value="竹林七贤" /></bean></beans>(2) 在配置文件springmvc.xml中创建bean标签并赋值
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><!--property:表示为类中属性注入值，调用的为set方法name:表示属性名value:注入基本类和字符串类型时使用valueref:注入的是实体类名以及接口类型等--><bean id="stu" class="com.wt.entity.Student"><property name="name" value="阮籍" /><property name="age" value="23" /><property name="claszz" ref="claszz" /><property name="hobby"><list><value>看电影</value><value>追海报</value><value>吹牛皮</value></list></property><property name="sex"><array><value>1</value><value>0</value><value>2</value></array></property><property name="set"><set><value>一二三</value><value>数星星</value><value>弹吉他</value></set></property><property name="map"><map><entry key="一" value="数羊"/><entry key="二" value="数鸡"/><entry key="三" value="数星星"/></map></property></bean><bean id="claszz" class="com.wt.entity.Claszz" ><property name="id" value="7" /><property name="name" value="竹林七贤" /></bean></beans>4.自动注入
(1) 创建接口类
public interface IUserDao {public void fun();
}(2) 创建两个类并实现IUserDao接口
//类1
public class UserDao implements IUserDao{public void fun() {System.out.println("进入了UserDao的实现类中+++++++++++++++++++");}
}//类2
public class UserDao02 implements IUserDao{public void fun() {System.out.println("+++++++++++++++++++++进入了UserDao02的实现类");}
}(3) 创建controller类，并引用接口
@Data
public class UserDaoController {private IUserDao iuserDao;public void show(){iuserDao.fun();}
}(4)在springmvc.xml中建立bean标签
通过byType、byName自动注入bean对象
ps:
a.通过byType注入bean对象时，同一类型下不能有多个类
b..通过byName注入bean对象时，下方的bean标签的id必须有一个与controller中的引用类型名相同
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="userDaoController" class="com.wt.entity.UserDaoController" autowire="byType">
<!-- <property name="IUserDao" ref="userDao02" />--></bean><!-- <bean id="iuserDao" class="com.wt.entity.UserDao" ></bean>--><bean id="userDao02" class="com.wt.entity.UserDao02" ></bean></beans>(5) 建立测试类
public class Test01 {public static void main(String[] args) {ApplicationContext app = new ClassPathXmlApplicationContext("springmvc.xml");UserDaoController userDaoController = app.getBean("userDaoController", UserDaoController.class);userDaoController.show();}
}
5.使用注解完成IOC和DI功能
(1) 在springmvc中配置包扫描文件
<!--包扫描--><context:component-scan base-package="com.wt"/>(2) 创建controller
//表示控制层注解,如何没有设置bean的id 默认为类的名称首字母小写 相当于在spring配置文件钟<bean id="" class="com.wt.emtity02.UserController"/>
@Controller
public class UserController {//@Autowired 按照类型自动注入 如果需要自己指定id名注入需要使用另一个注解配合使用@Autowired@Qualifier("userDao02") //<property name="userDao" ref="userDao02">private UserDao userDao;public void fun(){userDao.print();}
}(3) dao接口和实现类
可以使用以下四种注解：
@Controller+@Respository+@Service+@Component
四种注解没有区别: 他们的底层都是用的@Component
实际意思就在于区分层的。
@Controller控制层
@Respository持久化层
@Service 业务层
@Component 最底层的bean注解。ps:如果不在其后面跟value的话，则默认类名首字母小写
@Controller
public class UserDao implements IUserDao{public void show() {System.out.println("进入了UserDao的实现类中+++++++++++++++++++");}
}@Controller
public class UserDao02 implements IUserDao{public void show() {System.out.println("进入了UserDao02的实现类中+++++++++++++++++++");}
}
(4) 常见错误
学习Spring框架有这一篇就够了相关推荐
- 每天一点儿时间学习Spring框架系列—IOC(2)
每天一点儿时间学习Spring框架--Ioc(2) 前篇简单入门了Spring的结构,这次就来开始讨论其中的控制反转的思想和自己的一些编写实例分享.(编写不一定能够完美的实现,建议大家了解其中的基本步 ...
- Spring入门，看这篇就够了
Spring入门,看这篇就够了 文章目录 Spring入门,看这篇就够了 一. 初识Spring 二.Spring Framework系统架构 三.核心概念 1.IoC(inversion of co ...
- 学习Spring，看这几本书就够了
如果想看更多技术好书,可以关注微信公众号[程序员书单]作者黄小斜,目前是阿里Java工程师,业余时间广泛读书,在公众号里除了分享程序员必读的技术书籍之外,也会推荐很多关于个人成长.投资理财等方面的书籍 ...
- 深入学习Spring框架（二）- 注解配置
1.为什么要学习Spring的注解配置? 基于注解配置的方式也已经逐渐代替xml.所以我们必须要掌握使用注解的方式配置Spring. 关于实际的开发中到底使用xml还是注解,每家公司有着不同的使用习惯 ...
- 深入学习Spring框架之一Spring的简要概括
Java开发的春天 Spring框架最初的形成,来自于最初的一位Java领域的大牛-----Rod Jahnson.这位大牛所著的一本叫做<Expert One-on-One J2EE Desi ...
- springaop事务逻辑原理_搞懂Spring AOP，这一篇就够了
看了这篇文章,如果你还是不会用AOP来写程序,请你打我!! =.=||| 引言 Spring AOP是一个对AOP原理的一种实现方式,另外还有其他的AOP实现如AspectJ等. AOP意为面向切面编 ...
- 学习SQL数据更新，这一篇就够了！
[任务描述] 数据查询不能改变数据库中的数据,仅仅是把数据库中符号条件的某些信息反馈给用户.一个数据库若要保持数据的正确性.及时性.则要依赖于数据库的更新功能.数据更新主要包括插入数据.修改数据和删除 ...
- 深度学习与计算机视觉 看这一篇就够了
来源:http://www.leiphone.com/news/201605/zZqsZiVpcBBPqcGG.html#rd 人工智能是人类一个非常美好的梦想,跟星际漫游和长生不老一样.我们想制造出 ...
- 学习 Butterfly主题美化 这一篇就够了
目录 一.主题配置文件修改 1.1.基础配置 1.2.导航栏配置(一) 1.3.导航栏配置(二) 1.4.副标题配置 一.主题配置文件修改 1.1.基础配置 主目录下 _config.yml # Si ...
最新文章
- COM 组件设计与应用(六)——用 ATL 写第一个组件(vc.net)
- C# 8的Ranges和递归模式
- Invalid indirect reference 0x28 in decodeIndirectR
- 面向对象的软件测试技术
- 怎么修改CAD编辑器中默认的线型
- PCANet --- 用于图像分类的深度学习基准
- html调试模式查看data数据库,接口调试：在线sql语句查看与性能优化
- Android动态加载进阶 代理Activity模式
- NLP之WE之CBOWSkip-Gram：CBOWSkip-Gram算法概念相关论文、原理配图、关键步骤之详细攻略
- 【入门基础】conda+jupyter玩转数据科学环境搭建
- LinkedHashMap，HashMap，TreeMap
- Java 15 即将到来，新特性速览！
- FragmentPagerAdapter.notifyDataSetChanged()不能更新问题？
- 交叉火力dsp手机调音软件_dsp教程_交叉火力dsp调音教程_教你学dsp百度云
- settimeout在各个浏览器的最小时间
- 叮咚志汇超级外卖餐饮 6.3.8 + 超级跑腿 v2.0.3 打包下载 小程序模块
- [转]信息安全相关理论题(四)
- wav格式怎样转换成flac
- 如何使用SPSS列联表分析，查看变量间的相关关系（下）
- CLC龍链：致力于打造支付生态系统