标签：set 遍历 是什么 main方法 谈恋爱 runtime 特征 不容易 aik
Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：
反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring
MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多
著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架。
1998 年，SUN 制定开发标准规范 EJB1.0
1999 年，EJB1.1 发布
2001 年，EJB2.0 发布
2003 年，EJB2.1 发布
2006 年，EJB3.0 发布
Rod Johnson（spring 之父）
Expert One-to-One J2EE Design and Development(2002)
阐述了 J2EE 使用 EJB 开发设计的优点及解决方案
Expert One-to-One J2EE Development without EJB(2004)
阐述了 J2EE 开发不使用 EJB 的解决方式（Spring 雏形）
2017 年 9 月份发布了 spring 的最新版本 spring 5.0 通用版（GA）
通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造
成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可
以更专注于上层的应用。
通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
Spring 可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。
Spring 对 JavaEE API（如 JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些 API 的使用难度大为降低。
Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java 设计模式灵活运用以及对 Java 技术的高深造诣。它的源代码无意是 Java 技术的最佳实践的范例。
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调
用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关
系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立
性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。
在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计
应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个
准则就是高内聚低耦合。
它有如下分类：
（1）内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另
一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
（2）公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大
量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
（3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传
递该全局变量的信息，则称之为外部耦合。
（4） 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进
行适当的动作，这种耦合被称为控制耦合。
（5）标记耦合 。若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间
存在一个标记耦合。
（6） 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形
式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另
一些模块的输入数据。
（7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实
现的。
总结：
耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须
存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。
内聚与耦合
内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从
功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。
内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同他
模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。
Class.forName("com.mysql.jdbc.Driver");//此处只是一个字符串
此时的好处是，我们的类中不再依赖具体的驱动类，此时就算删除 mysql 的驱动 jar 包，依然可以编译（运行就不要想了，没有驱动不可能运行成功的）。
同时，也产生了一个新的问题，mysql 驱动的全限定类名字符串是在 java 类中写死的，一旦要改还是要修改
源码。
解决这个问题也很简单，使用配置文件配置。
在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。
那么，这个读取配置文件，创建和获取三层对象的类就是工厂。
工厂类：
public class BeanFactory {
private static Properties properties;
//创建单例的容器，用于存储要创建的bean对象
private static Map<String,Object> beans;
static {
try {
properties = new Properties();
//加载配置文件
properties.load(BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties"));
//实例化map容器
beans = new HashMap<String, Object>();
//获取properties的所有keys
Set<Object> keys = properties.keySet();
//遍历key
for (Object o : keys) {
//强转为String类型
String key = (String)o;
//获取properties集合key对应的全限定类名
String beanPath = properties.getProperty(key);
//使用反射技术创建对象
Object bean = Class.forName(beanPath).newInstance();
//将创建的对象存储到beans容器
beans.put(key,bean);
}
} catch (IOException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 此方法是使用单利模式创建所对应的对象
* @param beanName
* @return
*/
public static Object getBean(String beanName){
return beans.get(beanName);
}
/**
* 根据bean的名称获取对象 此方法创建的是多例模式
* @param beanName
* @return
*/
public static Object getBean(String beanName) {
Object bean = null;
try {
String beanPath = properties.getProperty(beanName);
bean = Class.forName(beanPath).newInstance();
return bean;
}catch (Exception e){
}
return bean;
}
}
配置文件
AccountServiceImpl=com.service.impl.AccountServiceImpl
AccountDaoImpl=com.dao.impl.AccountDaoImpl
创建对象
IAccountService accountService = (IAccountService) BeanFactory.getBean("AccountServiceImpl");
IAccountDao dao = (IAccountDao)BeanFactory.getBean("AccountDaoImpl");
****（Inversion of Control，缩写为IoC）是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI**），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
IOC是削减程序之间的耦合度，而不能完全消除。
我们普通的通过new的方式获取对象
使用工厂模式创建对象
IoC(控制反转)
首先想说说IoC（Inversion of Control，控制反转）。这是spring的核心，贯穿始终。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection等），对象始终会和其他的接口或类藕合起来。
那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。所有的类的创建、销毁都由 spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。
DI(依赖注入)
IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。比如对象A需要操作数据库，以前我们总是要在A中自己编写代码来获得一个Connection对象，有了 spring我们就只需要告诉spring，A中需要一个Connection，至于这个Connection怎么构造，何时构造，A不需要知道。在系统运行时，spring会在适当的时候制造一个Connection，然后像打针一样，注射到A当中，这样就完成了对各个对象之间关系的控制。A需要依赖 Connection才能正常运行，而这个Connection是由spring注入到A中的，依赖注入的名字就这么来的。那么DI是如何实现的呢？ Java 1.3之后一个重要特征是反射（reflection），它允许程序在运行的时候动态的生成对象、执行对象的方法、改变对象的属性，spring就是通过反射来实现注入的。
理解了IoC和DI的概念后，一切都将变得简单明了，剩下的工作只是在spring的框架中堆积木而已。
链接：https://www.zhihu.com/question/335362570/answer/753288166
来源：知乎
meaven的依赖配置文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.itheima</groupId>
<artifactId>SpringDemo</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
</dependencies>
</project>
service业务层
public class UserServiceImpl implements IUserService {
public void saveUser() {
System.out.println("用户已经保存");
}
}
配置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">
<!--class是创建类的全限定类名-->
<bean id="userService" class="service.impl.UserServiceImpl"></bean>
</beans>
测试
public class SpringTest01 {
public static void main(String args[]){
//获取SpringIOC的核心容器，并根据id获取对象
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IUserService userService = (IUserService)ac.getBean("userService");
userService.saveUser();
}
}
3.2.1 Spring中工厂的类结构图
BeanFactory 才是 Spring 容器中的顶层接口。
ApplicationContext 是它的子接口。
- BeanFactory 和 ApplicationContext 的区别：
创建对象的时间点不一样。
ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。用于创建单例模式
BeanFactory：什么使用什么时候创建对象。用于创建多例模式
ApplicationContext的三个常用类：
ClassPathXmlApplicationContext(String configLocation):
他可以加载类路径下的配置文件，要求配置文件是在类路径下，不在的话加载不了（常用）
FileSystemXmlApplicationContext(String configLocation)
他可以加载磁盘上任意位置上面的配置文件（要有访问权限）
AnnotationConfigApplicationContext:
他可以读取注解创建容器
创建bean的方式有三种
作用：
用于配置对象让 spring 来创建的。
默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性：
id：给对象在容器中提供一个唯一标识。用于获取对象。
class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
scope：指定对象的作用范围。
- singleton :默认值，单例的.
- prototype :多例的.
- request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
- session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
- global session（集群） :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session
- init-method：指定类中的初始化方法名称。
- destroy-method：指定类中销毁方法名称。
单例对象：scope="singleton"
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象：scope="prototype"
每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。
方式一：使用默认构造函数进行创建
在Spring的配置文件中使用bean标签，配置id和class之后，没有其他属性和标签时，
采用的就是默认构造函数创建bean对象，此时类中如果没有空参构造方法，则无法创建对象
<bean id="accountService" class="com.service.impl.AccountServiceImpl"></bean>
方式二：spring 管理实例工厂-使用实例工厂的方法创建对象
使用某个类中的方法创建并存入Spring的IOC容器中，这种方式一般是存在于jar包中使用实例方法创建对象的方式
/**
* 模拟一个工厂类（该类可能存在于jar包中，我们无法通过修改源码的方式来提供构造函数）
* @param
* @return
*/
public class InstanceFactory {
public IAccountService getIAccountService(){
return new AccountServiceImpl();
}
}
<bean id="instanceFactory" class="com.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instanceFactory" factory-method="getIAccountService"></bean>
此种方式是先把工厂的创建交给 spring 来管理。然后再使用工厂的 bean 来调用里面的方法
factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。方式三：
方式三：spring 管理静态工厂-使用静态工厂的方法创建对象
使用某个类中的方法创建并存入Spring的IOC容器中，这种方式一般是存在于jar包中使用静态方法创建对象的方式
/**
* 模拟一个工厂类,使用静态方法创建IAccountService对象（该类可能存在于jar包中，我们无法通过修改源码的方式来提供构造函数）
* @param
* @return
*/
public class StaticInstanceFactory {
public static IAccountService getIAccountService(){
return new AccountServiceImpl();
}
}
<bean id="accountService" class="com.factory.StaticInstanceFactory" factory-method="getIAccountService"></bean>
使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
id 属性：指定 bean 的 id，用于从容器中获取
class 属性：指定静态工厂的全限定类名
factory-method 属性：指定生产对象的静态方法
依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。
依赖注入：
Dependency Injection
IOC的作用：
降低程序间的依赖关系即降低耦合
依赖关系的管理：
都交给了Spring来维护
在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明
依赖关系的维护：
我们就称之为依赖注入
依赖注入：
能注入的数据有三类：
基本数据类型和String
其他的bean类型（在配置文件中或者注解配置过的bean）
复杂类型/集合类型
注入的方式有三种：
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供
使用标签constructor-arg
使用出现在bean标签的内部
标签中的属性：
type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引的位置是从0开始的
name：用于指定个构造函数中指定名称的参数赋值（常用）
以上三个用于指定给构造函数中哪个参数赋值===
value：用于提供基本类型和String类型的数据
ref：用于指定的其他bean类型数据，他指的就是在spring的IOC核心容器中出现过的bean对象? 优势：在注入数据时，使用者必须要注入数据，否则对象无法创建成功，可以不让使用者遗忘数据的注入
? 弊端：改变了bean对象的实例化方式，使我们在创建对象时，即使用不到这些数据，也必须注入
public class AccountServiceImpl implements IAccountService {
private String name;
private Integer age;
private Date birthday;
public AccountServiceImpl(String name,Integer age,Date birthday){
this.name=name;
this.age=age;
this.birthday=birthday;
}
/**
* 保存用户
*/
@Override
public void saveAccount() throws Exception{
System.out.println("service中的saveAccount方法执行了 ");
}
@Override
public String toString() {
return "AccountServiceImpl{" +
"name=‘" + name + ‘\‘‘ +
", age=" + age +
", birthday=" + birthday +
‘}‘;
}
}
<bean id="accountService" class="com.service.impl.AccountServiceImpl">
<constructor-arg name="name" value="test"></constructor-arg>
<!--Integer类型spring能直接进行类型转型为Integer类型-->
<constructor-arg name="age" value="18"></constructor-arg>
<!--java.util.Date类型不能直接进行spring能直接进行转型-->
<constructor-arg name="birthday" ref="date"></constructor-arg>
</bean>
<!--配置一个日期对象,将来用于引用-->
<bean id="date" class="java.util.Date"></bean>
第二种：set方法注入 （更常用的方式 ）
使用的标签是property
使用在bean标签的内部
标签的属性：
name：找用于指定注入时所调用的set方法名称
value：用于提供基本类型和String类型的数据
ref：用于指定的其他bean类型数据，他指的就是在spring的IOC核心容器中出现过的bean对象
优势：创建对象时，没有明确限制
劣势：如果有某成员必须有值，则容易造成遗忘
<bean id="accountService2" class="com.service.impl.AccountServiceImpl2">
<property name="name" value="test02"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="date2"></property>
</bean>
<!--配置一个日期对象,将来用于引用-->
<bean id="date2" class="java.util.Date"></bean>
/**
* 账户的业务层实现类
* @param
* @return
*/
public class AccountServiceImpl2 implements IAccountService {
private String name;
private Integer age;
private Date birthday;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
/**
* 保存用户
*/
@Override
public void saveAccount() throws Exception{
System.out.println("service2中的saveAccount方法执行了 ");
}
@Override
public String toString() {
return "AccountServiceImpl{" +
"name=‘" + name + ‘\‘‘ +
", age=" + age +
", birthday=" + birthday +
‘}‘;
}
}
用于给集合结构注入的标签
list array set
用于给map结构注入的标签
map props
结构相同的时候，可以任意使用，开发中一般都用set和map则这两种结构
<bean id="accountService3" class="com.service.impl.AccountServiceImpl3">
<!--注入数组-->
<property name="myStrs">
<array>
<!--数组中的元素-->
<value>a</value>
<value>b</value>
<value>c</value>
</array>
</property>
<!--注入list集合-->
<property name="myList">
<list>
<value>d</value>
<value>e</value>
<value>f</value>
</list>
</property>
<!--注入set集合-->
<property name="mySet">
<set>
<value>g</value>
<value>h</value>
<value>i</value>
</set>
</property>
<!--注入map集合-->
<property name="myMap">
<map>
<!--map集合的映射方式1-->
<entry key="k1" value="张三"></entry>
<!--map集合的映射方式2-->
<entry key="k2">
<!--value表示值的类型-->
<value type="java.lang.String">李四</value>
</entry>
</map>
</property>
<property name="myPros">
<props>
<prop key="p1">这是p1的内容</prop>
<prop key="p2">这里p2的内容</prop>
</props>
</property>
</bean>
/**
* 账户的业务层实现类
* @param
* @return
*/
public class AccountServiceImpl3 implements IAccountService {
private String[] myStrs;
private List<String> myList;
private Set<String> mySet;
private Map<String,String> myMap;
private Properties myPros;
public String[] getMyStrs() {
return myStrs;
}
public void setMyStrs(String[] myStrs) {
this.myStrs = myStrs;
}
public List<String> getMyList() {
return myList;
}
public void setMyList(List<String> myList) {
this.myList = myList;
}
public Set<String> getMySet() {
return mySet;
}
public void setMySet(Set<String> mySet) {
this.mySet = mySet;
}
public Map<String, String> getMyMap() {
return myMap;
}
public void setMyMap(Map<String, String> myMap) {
this.myMap = myMap;
}
public Properties getMyPros() {
return myPros;
}
public void setMyPros(Properties myPros) {
this.myPros = myPros;
}
@Override
public void saveAccount() throws Exception {
System.out.println("save方法执行");
System.out.println(Arrays.toString(myStrs));
System.out.println(mySet);
System.out.println(myMap);
System.out.println(myPros);
}
使用注解配置需要在bean.xml 文件引入xmlns依赖，并且需要告知Spring容器在创建的时候要扫描的包，配置所需的标签不是bean的约束中，而是一个名为context名称空间和约束中
<context:component-scan base-package="com.itheima"></context:component-scan>
他们的作用和使用xml配置配置文件的
作用：用于把当前对象存入到Spring的IOC容器中
? 属性：
? value：用于指定bean的id，默认为当前类型且首字母小写
作用：和@Component标签的作用一致，spring用于区分三层架构的表现层
作用：和@Component标签的作用一致，spring用于区分三层架构的业务层
作用：和@Component标签的作用一致，spring用于区分三层架构的持久层
以上三个注解他们的作用和属性和Component是一致的
他们三个是Spring框架为我们提供明确的使用三层架构使用的注解，使我们的三层架构更加清晰
他们的作用和xml配置文件中的bean标签中的
一般出现在变量和方法中
作用：
自动按照类型注入，只要容器中有唯一的bean对象类型和要注入的变量类型匹配，就可以注入成功，
如果IOC容器没有任何bean的类型和要注入的变量类型匹配则报错
如果IOC容器中有多个 bean的类型相同时，先圈定出这些对象，再根据注入变量的变量名去和IOC容器中的 key进行匹配，如果都没有匹配上，则报错
细节：
使用注解方式注入set方法就不是必须的了
作用：在按照类型注入的基础之上再按照名称注入，它在给类成员注入时不能单独使用，在给方法参数注入时可以单独使用
作用：直接按照bean的id注入，他可以直接使用
属性：
? name：用于指定bean的id
以上三个注解只能注入其他类型bean类型的数据，而基本类型和String类型无法使用上述注解实现，另外，集合类型的注入只能通过xml配置的形式来实现
作用：用于注入基本数据类型和String类型
属性：
? value：用于指定数据的值，它可以使用Spring中的SpEL(Spring的EL表达式)
? SpEL的写法：${表达式}
// @Autowired
// @Qualifier("accountDao1")
@Resource(name = "accountDao2")
private IAccountDao accountDao = null;
他们的作用和
作用：用于指定bean的作用范围
属性：
? value：用于指定作用范围，常取值为：singleton（单例，默认值） prototype（多例）
作用：用于指定销毁方法
细节：多例对象没有销毁方法，多例对象是长时间不使用后由java的垃圾回收机制回收
作用：用于指定初始化方法
@Component("accountService")
//@Scope("singleton")//创建的是单例对象，Spring默认的
//@Scope("prototype")//创建的是多例对象，
public class AccountServiceImpl implements IAccountService {
// @Autowired
// @Qualifier("accountDao1")
@Resource(name = "accountDao2")
private IAccountDao accountDao = null;
/**
* 保存用户
*/
@Override
public void saveAccount() {
accountDao.saveAccount();
}
@PostConstruct//声明是初始化方法
public void init(){
System.out.println("初始化方法执行");
}
@PreDestroy//声明是销毁方法
public void destroy(){
System.out.println("销毁方法执行");
}
}
作用：
? 指定当前类是一个配置类
细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可不写
作用：
? 通过注解指定Spring需要扫描的包
属性：
? value：和xml的context：component-scan basePackages的作用是一致的，都是用于指定创建容器时要扫描的包，我们使用此注解相当于用xml配置了<context:component-scan base-package="com.itheima"></context:component-scan>
@ComponentScan("com.itheima")
作用：用于把当前方法的返回值作为bean对象存入Spring的ioc容器中
属性：
? name：用于指定bean的id，当不写时，默认为该方法名
细节：当我们使用注解配置的方式，如果方法有参数，Spring会自动去ioc容器中查找有没有可用的bean对象，查找的方式和Autowired注解的作用是一致的
/**
* 用于创建一个QueryRunner对象
*
* @param ds
* @return
*/
@Bean(name = "queryRunner")
@Scope("prototype")
public QueryRunner createQueryRunner(DataSource ds) {
return new QueryRunner(ds);
}
作用：用于导入其他配置类
属性：
? value：用于指定其他配置类的字节码文件，当我们使用Improt注解后，有Import注解的类就是父配置类，而导入的是子配置类
@Configuration//标识为配置类
@ComponentScan("com.itheima")//spring需要扫描的包
@Import(JdbcConfig.class)//指定子配置类
@PropertySource("classpath:jdbc.properties")//指定jdbc.properties文件位置
public class SpringConfiguration {
}
作用：用于指定properties文件的位置
属性：
? value：指定文件的名称和路径
? 关键字：classpath：表示类路径下
当使用该配置后，properties文件的内容可以通过SpEL表达式的形式获取
获取方式：
如：@Value("${jdbc.driver}")
@PropertySource("classpath:jdbc.properties")//指定jdbc.properties文件位置
//配置文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/eesy_spring
jdbc.user=root
jdbc.password=123
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.user}")
private String user;
@Value("${jdbc.password}")
private String password;
当使用纯注解开发的方式时，获取ioc容器不再使用new ClassPathXmlApplicationContext("bean.xml")的方式，而是采用new AnnotationConfigApplicationContext(SpringConfiguration.class)的方式
Spring整合junit的配置：
? 1、导入Spring整合junit的jar或maven的坐标（Spring-test），同时junit的jar包必须是在4.12版本以上
<!--配置spring整合junit的jar包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<!--导入junit的jar包，必须是在4.12版本以上-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
? 2、使用Junit提供的@RunWit注解把junit原有的main方法替换，替换成Spring提供的
? 3、使用@ContextConfigurtion告知spring的运行器，spring的ioc创建是基于配置文件还是基于注解类，并且说明对应位置
? @ContextConfiguration的属性：
? locations：指定xml 文件的位置，注意要加上classpath关键字表示根目录
? classes：指定注解类所在的位置
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=SpringConfiguration.class)
public class AccountServiceTest {
//自动注入
@Autowired
private IAccountService service;
@Test
public void testFindAll() {
List<Account> accounts = service.findAll();
for (Account account : accounts) {
System.out.println(account);
}
}
}
package com.itheima.domain;
import java.io.Serializable;
public class Account implements Serializable {
private Integer id;
private String name;
private Integer money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getMoney() {
return money;
}
public void setMoney(Integer money) {
this.money = money;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name=‘" + name + ‘\‘‘ +
", money=" + money +
‘}‘;
}
}
package com.itheima.dao.impl;
import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.sql.SQLException;
import java.util.List;
/**
* @param
* @return
*/
@Service("accountDao")
public class AccountDaoImpl implements IAccountDao {
@Resource(name = "queryRunner")
private QueryRunner runner;
public void setRunner(QueryRunner runner) {
this.runner = runner;
}
@Override
public List<Account> findAll() {
try {
return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public Account findById(Integer accountId) {
try {
return runner.query("select * from account where id=?",new BeanHandler<Account>(Account.class),accountId);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public void saveAccount(Account account) {
try {
runner.update("insert into account(name,money) value(?,?)",account.getName(),account.getMoney());
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public void updateAccount(Account account) {
try {
runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
@Override
public void deleteAccount(Integer accountId) {
try {
runner.update("delete from account where id=?", accountId);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
package com.itheima.service.impl;
import com.itheima.dao.IAccountDao;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.springframework.stereotype.Controller;
import javax.annotation.Resource;
import java.util.List;
/**
* @param
* @return
*/
@Controller("accountService")
public class AccountServiceImpl implements IAccountService {
@Resource(name = "accountDao")
private IAccountDao dao;
@Override
public List<Account> findAll() {
return dao.findAll();
}
@Override
public Account findById(Integer accountId) {
return dao.findById(accountId);
}
@Override
public void saveAccount(Account account) {
dao.saveAccount(account);
}
@Override
public void updateAccount(Account account) {
dao.updateAccount(account);
}
@Override
public void deleteAccount(Integer accountId) {
dao.deleteAccount(accountId);
}
}
package config;
import org.springframework.context.annotation.*;
@Configuration//标识为配置类
@ComponentScan("com.itheima")//需要扫描的包
@Import(JdbcConfig.class)//指定配字配置类
@PropertySource("classpath:jdbc.properties")//指定properties文件位置
public class SpringConfiguration {
}
package config;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import javax.sql.DataSource;
/**
* 配置数据库
* @param
* @return
*/
//@Configuration
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.user}")
private String user;
@Value("${jdbc.password}")
private String password;
/**
* 用于创建一个QueryRunner对象
*
* @param ds
* @return
*/
@Bean(name = "queryRunner")
@Scope("prototype")
public QueryRunner createQueryRunner(DataSource ds) {
return new QueryRunner(ds);
}
/**
* 创建数据源对象
*
* @return
*/
@Bean(name = "dataSource")
public DataSource createDataSource() {
try {
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass(driver);
ds.setJdbcUrl(url);
ds.setUser(user);
ds.setPassword(password);
return ds;
}catch (Exception e){
throw new RuntimeException("数据库连接失败！");
}
}
}
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/eesy_spring
jdbc.user=root
jdbc.password=123
package com.itheima.test;
import config.SpringConfiguration;
import com.itheima.domain.Account;
import com.itheima.service.IAccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
/**
* @param
* @return
*/
public class AccountServiceTest {
@Test
public void testFindAll() {
// ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
//使用注解创建容器
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfiguration.class);
IAccountService service = context.getBean("accountService", IAccountService.class);
List<Account> accounts = service.findAll();
for (Account account : accounts) {
System.out.println(account);
}
}
@Test
public void testFindById() {
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
IAccountService service = (IAccountService)context.getBean("accountService");
Account account = service.findById(2);
System.out.println(account);
}
@Test
public void testSave() {
// ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
//使用注解创建容器
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfiguration.class);
IAccountService service = (IAccountService)context.getBean("accountService");
Account account = new Account();
account.setName("test");
account.setMoney(2000);
service.saveAccount(account);
}
@Test
public void testUpdate() {
// ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
//使用注解创建容器
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfiguration.class);
IAccountService service = (IAccountService)context.getBean("accountService");
Account account = service.findById(4);
account.setMoney(3000);
service.updateAccount(account);
}@Test
public void testDelete() {
// ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
//使用注解创建容器
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfiguration.class);
IAccountService service = (IAccountService)context.getBean("accountService");
service.deleteAccount(4);
}
}
标签：set 遍历 是什么 main方法 谈恋爱 runtime 特征 不容易 aik
原文地址：https://www.cnblogs.com/codeli/p/13074021.html
