文章目录
- IOC创建对象的方式
- Spring配置文件
- 依赖注入DI
- 使用注解实现IOC
- 代码实例
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
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
