目录
Spring系列
- Spring — Spring简介、入门、配置 , IoC和DI思想
- Spring — IoC核心(基于XML)、DI核心(基于XML)
- Spring — 使用IoC和DI模拟注册案例、注解配置IoC和DI
- Spring — 静态代理、动态代理、拦截器思想
- Spring — AOP思想、AOP开发、Pointcut语法、注解配置AOP
- Spring — DAO层、Spring JDBC、Spring事务控制
- Spring — XML配置事务、注解+XML、纯注解的配置方式
- Spring整合MyBatis
- Spring Java Config — 组件注册相关注解
- Spring Java Config — 常用注解
一、 使用IoC和DI模拟注册案例(XML配置)
- 数据库
CREATE TABLE `user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(40) NOT NULL,
`age` int(11) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
使用的一些类和接口
- 类和接口
// domain包下的User类
@Getter
@Setter
@ToString
public class User {
private Long id;
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
}
//--------------------------------------------
// controller包下的UserController类
// 模拟Struct2的Action / SpringMVC的Controller
public class UserController {
@Setter
private UserService service;
public String register(){
System.out.println("注册请求");
service.register(new User("朝阳", 100));
return "success";
}
}
//--------------------------------------------
// service包下的UserService接口和实现类
public interface UserService {
// 注册
void register(User u);
}
public class UserServiceImpl implements UserService {
@Setter
private UserDao dao;
public void register(User u) {
System.out.println("注册方法");
dao.save(u);
}
}
//--------------------------------------------
// dao包下的UserDao接口和实现类
public interface UserDao {
// 保存用户信息
void save(User u);
}
public class UserDaoImpl implements UserDao {
@Setter
private DataSource dataSource;
@SneakyThrows // 偷偷抛出已检查的异常
public void save(User u) {
System.out.println("保存操作");
@Cleanup // 处理资源关闭
Connection conn = dataSource.getConnection();
String sql = "INSERT INTO user(name ,age) VALUES(?,?)";
@Cleanup
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, u.getName());
ps.setInt(2, u.getAge());
ps.executeUpdate();
}
}
- db.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=1111
jdbc.initialSize=2
- xml文件(重点操作)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--从classpath的根路径去加载db.properties文件-->
<!--<context:property-placeholder location="classpath:db.properties" system-properties-mode="NEVER"/>-->
<context:property-placeholder location="classpath:db.properties"/>
<!--配置一个druid的连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
<property name="initialSize" value="${jdbc.initialSize}"/>
</bean>
<!--配置DAO-->
<bean id="userDao" class="com.sunny._06_register.dao.impl.UserDaoImpl">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--配置service-->
<bean id="userService" class="com.sunny._06_register.service.impl.UserServiceImpl">
<property name="dao" ref="userDao"/>
</bean>
<!--配置Action/Controller
如果使用Struct2的Action,此时bean的作用域应该是多例: scope="prototype"
如果使用的SpringMVC的Controller, 此时bean的作用域应该是单例的
-->
<bean id="userController" class="com.sunny._06_register.controller.UserController">
<property name="service" ref="userService"/>
</bean>
</beans>
- 测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RegisterTest {
// @Autowired:表示从Spring IoC容器中根据类型找到对应的bean,并自动注入到某个字段上
@Autowired
private UserController uc;
@Test
public void test(){
uc.register();
}
}
- 输出
二、注解配置IoC和DI
* 曾经XML的配置：
* <bean id="accountService" class="com.sunny.service.impl.AccountServiceImpl"
* scope="" init-method="" destroy-method="">
* <property name="" value="" | ref=""></property>
* </bean>
*
* 用于创建对象的
* 他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的
* Component:
* 作用：用于把当前类对象存入spring容器中
* 属性：
* value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。
* Controller：一般用在表现层
* Service：一般用在业务层
* Repository：一般用在持久层
* 以上三个注解他们的作用和属性与Component是一模一样。
* 他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰
*
*
* 用于注入数据的
* 他们的作用就和在xml配置文件中的bean标签中写一个<property>标签的作用是一样的
* Autowired:
* 作用：首先会根据对象的类型来找, 如果找到就直接通过setter方法注入;
* 如果存在多个类型的bean, 此时可以通过@Qualifier(“bean的id”)来一起查找
* 如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。
* 如果Ioc容器中有多个类型匹配时：可以结合@Qualifier("bean的id")来确定
* 出现位置：
* 可以是变量上，也可以是方法上
* 细节：
* 在使用注解注入到属性上时，set方法就不是必须的了。
* Qualifier:
* 作用：在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用。但是在给方法参数注入时可以（稍后我们讲）
* 属性：
* value：用于指定注入bean的id。
*
* Resource : 相当于 Autowird和Qualifier结合
* 作用：直接按照bean的name注入。它可以独立使用
* 属性：
* name：用于指定bean的id。
* 以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现。
* 另外，集合类型的注入只能通过XML来实现。
*
* Value
* 作用：用于注入基本类型和String类型的数据
* 属性：
* value：用于指定数据的值。它可以使用spring中SpEL(也就是spring的el表达式）
* SpEL的写法：${表达式}
*
* 用于改变作用范围的
* 他们的作用就和在bean标签中使用scope属性实现的功能是一样的
* Scope
* 作用：用于指定bean的作用范围
* 属性：
* value：指定范围的取值。常用取值：singleton prototype
*
* 和生命周期相关 了解
* 他们的作用就和在bean标签中使用init-method和destroy-methode的作用是一样的
* PreDestroy
* 作用：用于指定销毁方法
* PostConstruct
* 作用：用于指定初始化方法
1、DI注解
1.1、Autowired注解和Qualifier注解
Autowired首先会根据对象的类型来找, 如果找到就直接通过setter方法注入; 如果存在多个类型的bean, 此时可以通过@Qualifier(“bean的id”)来一起查找
Resource注解, 首先通过名字找(也就是id); 还可以通过@Resource(name = “”)的方式, 直接通过name找, 如果找不到就不会再根据类型找
@Resource
- @Resource默认按byName自动注入。
- 既不指定name属性，也不指定type属性，则自动按byName方式进行查找。如果没有找到符合的bean，则回退为一个原始类型进行进行查找，如果找到就注入。
- 只是指定了@Resource注解的name，则按name后的名字去bean元素里查找有与之相等的name属性的bean。
只指定@Resource注解的type属性，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常。
@Autowired
- @Autowired默认先按byType进行匹配，如果发现找到多个bean，则又按照byName方式进行匹配，如果还有多个，则报出异常。
Java类
public class Cat {
}
public class Person {
//@Autowired
private Cat c1;
/* @Autowired
public void setC1(Cat c1) {
this.c1 = c1;
}*/
@Override
public String toString() {
return "Person{" +
"c1=" + c1 +
'}';
}
}
将@Autowired贴在字段或者setter方法上,Spring会自动将该字段所需要的对象(cat对象)找出来并注入到该对象(person)中, 以前还需要在XML中手动将Cat用ref注入到Person对象中;
- xml配置
一定要配置DI注解解析器(对DI注解作解释)<context:annotation-config/>
<!--DI注解解析器
在Spring Test中,不用配就可以
在普通测试中,必须要配;
开发中一般都要配置!
-->
<context:annotation-config/>
<bean id="cat1" class="com.sunny.di.Cat"/>
<bean id="cat2" class="com.sunny.di.Cat"/>
<bean id="person" class="com.sunny.di.Person"/>
1.2、Resource注解
// 只会去找id为cat1的Cat对象,如果找不到就直接报错!
@Resource(name = "cat1")
private Cat c1;
注意: @Autowired和@Resource基本上功能一模一样,开发中两者选其一即可!
1.3、Value注解
跳转到目录
Autowired和Resource注解用于注入对象, Value注解用于注入常量数据(简单类型数据);
server.properties
server.port=781
Java类
public class ValueBean {
//@Value("9999") // 可以直接值注入
@Value("${server.port}") // 也可以通过SpEL的方式来注入配置文件中的key
private int port;
@Override
public String toString() {
return "ValueBean{" +
"port=" + port +
'}';
}
}
xml文件
<!--DI注解解析器
在Spring Test中,不用配就可以
在普通测试中,必须要配;
开发中一般都要配置!
-->
<context:annotation-config/>
<!--加载properties文件-->
<context:property-placeholder location="classpath:db.properties, classpath:server.properties "/>
<bean id="valueBean" class="com.sunny.di.ValueBean"/>
测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class DiTest {
//@Autowired
@Resource
private Person person;
@Autowired
private ValueBean valueBean;
@Test
public void test(){
System.out.println(person);
System.out.println(valueBean);
}
}
2、IoC注解
跳转到目录
bean组件版型:四个组件的功能是相同的,只是用于标注不同类型的组件。
- @Component泛指组件，当组件不好归类的时候,我们可以使用这个注解进行标注。
- @Repository用于标注数据访问组件, 即DAO组件。
- @Service用于标注业务层组件。
- @Controller用于标注控制层组件(如struts中的Action , SpringMVC的Controller) .
配置IoC注解解析器
<!--IoC注解解析器-->
<context:component-scan base-package="com.sunny.ioc"/>
表示去哪些包中及其子包中扫描组件注解
Java类
// XML配置方式: <bean id="myDataSource" class="com.sunny.ioc.MyDataSource"/>
// 注解配置: @Component
@Component("myDataSource") //组件如果不写value属性值,此时bean的id默认是类型首字母小写:myDataSource
public class MyDataSource {
}
xml文件
<!--DI注解解析器-->
<context:annotation-config/>
<!--IoC注解解析器-->
<context:component-scan base-package="com.sunny.ioc"/>
<!--以前使用XML的方式,交给Spring容器来创建MyDataSource对象-->
<!--<bean id="myDataSource" class="com.sunny.ioc.MyDataSource"/>-->
测试类
@Autowired
private MyDataSource mds;
@Test
public void test(){
System.out.println(mds);
}
两种方式都可以成功创建MyDataSource对象!
3、作用域注解和初始化、销毁注解
- 作用域注解使用
@Scope注解 - 设置初始化方法的注解使用
@PostConstruct用于贴在初始化方法上 - 设置销毁方法的注解使用
@PreDestroy用于贴在销毁方法上
java类
@Component
//@Scope("prototype") // 默认不写就是单例的
//@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class SomeBean {
public SomeBean() {
System.out.println("构造SomeBean对象");
}
@PreDestroy // 销毁对象之前执行
public void close() {
System.out.println("销毁方法");
}
@PostConstruct // 构建对象之后执行
public void open() {
System.out.println("初始化方法");
}
public void doWork() {
System.out.println("工作");
}
}
<!--老方式-->
<!--<bean id="someBean" class="com.sunny.lifecycle.SomeBean"
init-method="open" destroy-method="open"
/>-->
<!--配置IoC注解解析器-->
<context:component-scan base-package="com.sunny.lifecycle"/>
测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class LifeCycleTest {
@Autowired
private SomeBean sb1;
@Autowired
private SomeBean sb2;
@Test
public void test(){
System.out.println(sb1);
System.out.println(sb2);
sb1.doWork();
}
}
4、 IoC和DI其实是同一个东西
- IoC: 字面上,更多强调的是Spring容器帮我们创建对象
- DI: 字面上,Spring不仅帮我们创建对象,还要为该对象设置依赖的数据
5、@Mapper和@Repository注解的区别
在用IDEA写一个实现类时引用了mapper类的来调用dao层的处理，使用@Autowired注解时被标红线，找不到bean。IDEA联想不到, 在运行时就不会出现问题;
- 解决办法：在mapper加
@mapper或者@repository注解。
这两种注解的区别在于：
- 使用@mapper后，不需要在spring配置中设置扫描地址，通过mapper.xml里面的namespace属性对应相关的mapper类，spring将动态的生成Bean后注入到ServiceImpl中。
- @repository则需要在Spring中配置扫描包地址，然后生成dao层的bean，之后被注入到ServiceImpl中
三、 使用IoC和DI模拟注册案例(注解配置)
- 数据库
CREATE TABLE `user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`name` varchar(40) NOT NULL,
`age` int(11) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
使用的一些类和接口
- 类和接口
// domain包下的User类
@Getter
@Setter
@ToString
public class User {
private Long id;
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
}
//--------------------------------------------
// controller包下的UserController类
// 模拟Struct2的Action / SpringMVC的Controller
@Controller
public class UserController {
//@Setter
@Autowired
private UserService service;
public String register(){
System.out.println("注册请求");
service.register(new User("阳仔", 99));
return "success";
}
}
//--------------------------------------------
// service包下的UserService接口和实现类
public interface UserService {
// 注册
void register(User u);
}
@Repository
public class UserServiceImpl implements UserService {
//@Setter
@Autowired // 是按类型去找
private UserDao dao;
public void register(User u) {
System.out.println("注册方法");
dao.save(u);
}
}
//--------------------------------------------
// dao包下的UserDao接口和实现类
public interface UserDao {
// 保存用户信息
void save(User u);
}
@Repository
public class UserDaoImpl implements UserDao {
//@Setter
@Autowired
private DataSource dataSource;
@SneakyThrows // 偷偷抛出已检查的异常
public void save(User u) {
System.out.println("保存操作");
@Cleanup // 处理资源关闭
Connection conn = dataSource.getConnection();
String sql = "INSERT INTO user(name ,age) VALUES(?,?)";
@Cleanup
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, u.getName());
ps.setInt(2, u.getAge());
ps.executeUpdate();
}
}
- db.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=1111
jdbc.initialSize=2
- xml文件(重点操作)
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--DI注解解析器-->
<context:annotation-config/>
<!--IoC注解解析器
会自动扫描register的子包
-->
<context:component-scan base-package="com.sunny._01_register"/>
<!--从classpath的根路径去加载db.properties文件-->
<context:property-placeholder location="classpath:db.properties, classpath:server.properties "/>
<!--<context:property-placeholder location="classpath:db.properties" ignore-resource-not-found="true"/>
<context:property-placeholder location="classpath:server.properties" ignore-resource-not-found="true"/>-->
<!--配置一个druid的连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
init-method="init" destroy-method="close">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
<property name="initialSize" value="${jdbc.initialSize}"/>
</bean>
</beans>
- 测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class RegisterTest {
// @Autowired:表示从Spring IoC容器中根据类型找到对应的bean,并自动注入到某个字段上
@Autowired
private UserController uc;
@Test
public void test(){
uc.register();
}
}
- 输出
313
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
