IOC创建对象的方式
平时创建对象的方式:
- 有参构造
- 无参构造
现在来看看在Spring中怎么处理这两种情况
1、在pojo包下创建实体类,代码如下:
public class User {
private String name;
private String sex;
private int age;
public User() {
System.out.println("User的无参构造");
}
public User(String name) {
System.out.println("User的有参构造");
this.name = name;
}
public User(String name, int age) {
System.out.println("User的有参构造2");
this.name = name;
this.age = age;
}
public User(String name, String sex, int age) {
System.out.println("User的有参构造3");
this.name = name;
this.sex = sex;
this.age = age;
}
public void setName(String name) {
System.out.println(name+":"+System.currentTimeMillis());
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
2、在resources包下编写Spring的配置文件,代码如下:
<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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的配置文件
bean 代表一个对象
alias 别名
import 导入一个其他资源
-->
<bean id="user" class="pojo.User">
<!--使用property属性时,相当于使用了setXXX()方法-->
<!--使用construct-arg属性时,相当于使用了有参构造方法中的赋值方法-->
<property name="name" value="qinjiang"/>
</bean>
<!--使用构造器的参数下标进行赋值-->
<bean id="user2" class="pojo.User">
<constructor-arg index="0" value="kuangshen"/>
<constructor-arg index="1" value="18"/>
</bean>
<!--通过名字进行赋值-->
<bean id="user3" class="pojo.User">
<constructor-arg name="name" value="kuangshen3"/>
<constructor-arg name="age" value="3"/>
</bean>
<!--通过类型进行赋值-->
<bean id="user4" class="pojo.User">
<constructor-arg type="java.lang.String" value="kuangshen4"/>
<constructor-arg type="java.lang.Integer" value="18"/>
<constructor-arg type="java.lang.String" value="男"/>
</bean>
</beans>
3、在test包下编写测试类,代码如下:
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class UserTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User)context.getBean("user");
/*
User user = new User();
user.setName("qinjiang");
*/
System.out.println(user.toString());
}
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user4");
System.out.println(user);
}
}
小结:
- 通过有参构造
- 通过下标
- 通过参数名【推荐】
- 通过参数类型
- 通过无参构造
- 默认会用无参构造
注意点:一定要有一个无参构造方法
事实上,也可以用其他方式来创建对象:可以选择查看怎么用工厂模式来创建
设置注入与构造注入的区别
Spring配置文件
- bean
<!--bean讲解:
1.没有id,没有name,我们依旧可以获取这个对象,但是不建议使用、需要使用类的class对象获取;
User bean = context.getBean(User.class);
2.id 就是对象的名字
3.class 就是要实例化的类
4.name就是别名
有id的时候,name是别名 , 没有id的时候,name就是对象的名字
别名可以起多个
-->
<bean id="user" name="userTwo,user3" class="pojo.User">
<property name="name" value="Spring"/>
</bean>
- alias
<!--alias讲解:
- name : 就是bean对象的id
2,alias : 对象的别名
-->
<alias name="user" alias="user4"/>
-
import
import一般在团队项目中会使用,每个人开发各自的beans.xml,最后用一个总的文件拼装起来。
<!--import讲解
作用:导入另外一个资源,把另外配置文件装进来
classpath*: 他会去所有地方寻找你的文件。【效率低】
classpath: 只会在classpath中寻找文件,找不到就报错;【建议使用】
file:填写文件路径url【不建议使用】
http:填写网络路径url【不建议使用】
-->
<import resource="classpath*:userBeans.xml"/>
<import resource="classpath:userBeans.xml"/>
<import resource="file:"/>
<import resource="http:"/>
依赖注入DI
DI(Dependency Injection)
依赖:指bean对象的创建依赖于Spring容器,bean对象所依赖的资源
注入:指bean对象所依赖的资源,由容器来设置和装配
- 构造器输入
- 有参构造
- 无参构造
- setter注入
- 要求被注入的属性,必须有set方法,而且set方法的名字需要规范(set+属性名,且属性名的首字母要大写)
常量注入
<!--普通字段-->
<property name="name" value="小明"/>
Bean注入
<!--引用其他bean使用ref-->
<property name="address" ref="addr"/>
数组注入
<!--数组的注入-->
<property name="books">
<array>
<value>西游记</value>
<value>水浒传</value>
<value>红楼梦</value>
<value>三国演义</value>
</array>
</property>
List注入
<!--List注入-->
<property name="hobbys">
<list>
<value>女孩</value>
<value>代码</value>
<value>电影</value>
<value>音乐</value>
</list>
</property>
Map注入
<!--Map的注入-->
<!--
标签:entry
键:使用key
值: 使用value
-->
<property name="card">
<map>
<entry key="IdCard" value="666666888888884444"/>
<entry key="银行卡" value="111122223333444"/>
</map>
</property>
Set注入
<!--Set注入-->
<property name="games">
<set>
<value>王者荣耀</value>
<value>绝地求生</value>
<value>LOL</value>
</set>
</property>
空值注入
<!--Null空值注入-->
<property name="girlFriend">
<null/>
</property>
Properties注入
<!--Properties注入-->
<property name="info">
<props>
<prop key="学号">201932301</prop>
<prop key="性别">男</prop>
<prop key="姓名">小明</prop>
</props>
</property>
命名空间注入
p命名空间注入:属性的注入
<!--p:property属性,命名空间注入-->
<bean id="user1" class="pojo.User" p:name="abc" p:age="18"/>
c命名空间注入:构造器的注入
<!--c:constructor构造器:命名空间注入-->
<bean id="user2" class="pojo.User" c:name="abc" c:age="19"/>
使用注解实现IOC
1、注解方式将Bean的定义信息和Bean实现类结合在一起,Spring提供的注解有
@Component
:实现Bean组件的定义@Repository
:用于标注DAO类@Service
:用于标注业务类@Controller
:用于标注控制器类
@Repository("userDao")
public class UserDaoImpl implements UserDao {
…
}
等效于与在XML配置文件中编写
<bean id="userDao"
class="dao.impl.UserDaoImpl" />
2、使用@Autowired
注解实现Bean的自动装配,默认按类型匹配,可以使用@Qualifier
指定Bean的名称
- 对类的成员变量进行标注
@Service("userService")
public class UserServiceImpl implements UserService {
@Autowired
@Qualifier("userDao")
private UserDao dao;
……
}
- 也可以对方法的入参进行标注
@Service("userService")
public class UserServiceImpl implements UserService {
private UserDao dao;
@Autowired
public void setDao((@Qualifier("userDao") UserDao dao) {
this.dao = dao;
}
……
}
3、使用注解信息启动Spring容器
<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/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<!-- 扫描包中注解标注的类 -->
<context:component-scan base-package="service,dao" />
</beans>
4、使用Java标准注解完成装配
使用@Resource注解实现组件装配,默认按名称匹配
- 为dao属性注入名为userDao的Bean
@Service("userService")
public class UserServiceImpl implements UserService {
@Resource(name = "userDao")
private UserDao dao;
……
}
- 查找名为dao的Bean,并注入给dao属性
@Service("userService")
public class UserServiceImpl implements UserService {
@Resource
private UserDao dao;
……
}
代码实例
下面我用一个小项目完整的展示Spring使用注解实现IOC
1、User实体类
package userTest.entity;
/**
* @author:
* @date:2019/11/4
* @aim:User实体类
*/
public class User {
private String name;
private String pwd;
public User(){}
public User(String name, String pwd) {
this.name = name;
this.pwd = pwd;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", pwd='" + pwd + '\'' +
'}';
}
}
2、Dao层
package userTest.dao;
import org.springframework.stereotype.Component;
import userTest.entity.User;
/**
* @author:
* @date:2019/11/4
* @aim:
*/
@Component("userDao")
public class UserDaoImpl implements UserDao {
@Override
public boolean addUser(User user) {
System.out.println("插入一条用户信息");
return true;
}
}
3、Service层
package userTest.service;
import org.springframework.stereotype.Service;
import userTest.dao.UserDao;
import userTest.entity.User;
import javax.annotation.Resource;
/**
* @author:
* @date:2019/11/4
* @aim:
*/
@Service("userService")
public class UserServiceImpl implements UserService {
//@Autowired
//@Qualifier("userDao") //两种注入方式
@Resource(name = "userDao")
private UserDao dao;
public UserDao getDao() {
return dao;
}
public void setDao(UserDao dao) {
this.dao = dao;
}
@Override
public boolean add(User user) {
boolean flag=dao.addUser(user);
return flag;
}
}
4、增强类
package userTest.aop;
import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import userTest.service.UserService;
import java.util.Arrays;
/**
* @author:
* @date:2019/11/4
* @aim:通知类,并在通知类上添加注解,描述那些切入点应该执行哪种增强处理
*/
@Controller("userAop")
@Aspect
public class UserServiceLogAop {
Logger log= Logger.getLogger(userTest.aop.UserServiceLogAop.class);
@Autowired
@Qualifier("userService")
private UserService service;
public UserService getService() {
return service;
}
public void setService(UserService service) {
this.service = service;
}
@Pointcut("execution(public boolean add(userTest.entity.User))")
public void pointcut(){}
@Before("pointcut()")
public void beforeAdd(JoinPoint jp){
log.info("调用"+jp.getTarget()+"的"+jp.getSignature()+"之前,参数为:"+ Arrays.toString(jp.getArgs()));
}
@AfterReturning(pointcut = "pointcut()",returning = "result")
public void afterAdd(JoinPoint jp, Object result){
log.info("调用"+jp.getTarget()+"的"+jp.getSignature()+"之后,返回值为:"+result);
}
@After("pointcut()")
public void finalTest(JoinPoint jp){
log.info(jp.getTarget()+"的"+jp.getSignature()+"方法执行结束");
}
}
5、配置文件
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:p="http://www.springframework.org/schema/p"
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/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd">
<!-- 扫描包中注解标注的类 -->
<context:component-scan base-package="userTest" />
<!--启用对于@AspectJ注解的支持-->
<aop:aspectj-autoproxy />
<!--使用p命名空间注入直接量-->
<bean id="user" class="userTest.entity.User"
p:name="Uzi" p:pwd="123456"/>
<!--使用构造注入-->
<bean id="user1" class="userTest.entity.User">
<constructor-arg index="0">
<value>TheShy</value>
</constructor-arg>
<constructor-arg name="pwd" >
<value>123456</value>
</constructor-arg>
</bean>
</beans>
6、测试类
package userTest.service;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import userTest.entity.User;
public class UserServiceImplTest {
@Test
public void add() {
ApplicationContext context=new ClassPathXmlApplicationContext("ApplicationContext3.xml");
UserService userService=(UserService)context.getBean("userService");
User user= (User) context.getBean("user");
User user1= (User) context.getBean("user1");
userService.add(user);
userService.add(user1);
}
}
7、结果
[INFO ] 2019-11-05 12:28:44,771 method:userTest.aop.UserServiceLogAop.beforeAdd(UserServiceLogAop.java:42)
调用userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)之前,参数为:[User{name='Uzi', pwd='123456'}]
插入一条用户信息
[INFO ] 2019-11-05 12:28:44,772 method:userTest.aop.UserServiceLogAop.finalTest(UserServiceLogAop.java:52)
userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)方法执行结束
[INFO ] 2019-11-05 12:28:44,773 method:userTest.aop.UserServiceLogAop.afterAdd(UserServiceLogAop.java:47)
调用userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)之后,返回值为:true
[INFO ] 2019-11-05 12:28:44,773 method:userTest.aop.UserServiceLogAop.beforeAdd(UserServiceLogAop.java:42)
调用userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)之前,参数为:[User{name='TheShy', pwd='123456'}]
插入一条用户信息
[INFO ] 2019-11-05 12:28:44,773 method:userTest.aop.UserServiceLogAop.finalTest(UserServiceLogAop.java:52)
userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)方法执行结束
[INFO ] 2019-11-05 12:28:44,773 method:userTest.aop.UserServiceLogAop.afterAdd(UserServiceLogAop.java:47)
调用userTest.service.UserServiceImpl@3c9754d8的boolean userTest.service.UserService.add(User)之后,返回值为:true