不知道Spring是啥?先来了解一下Spring吧!
1、新建一个Maven项目,导入依赖,这个项目当做父工程,在这个项目下面建module
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.3.3version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
dependency>
dependencies>
导入这个包的好处是,它会附带spring的很多依赖,否则就得一个一个导
2、编写pojo类
public class Hello {
private String str;
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
}
3、编写配置文件bean.xml(配置元数据),在resource目录下
<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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="hello" class="com.cgz.pojo.Hello">
<property name="str" value="Spring"/>
bean>
beans>
4、测试
public class MyTest {
public static void main(String[] args) {
//获取Spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
//我们的对象现在都在Spring中管理了,我们要使用,直接去里面取出来就可以
Hello hello = (Hello)context.getBean("hello");
System.out.println(hello.toString());
}
}
问:Hello对象是谁创建的? 答: Spring创建的
问:Hello对象的属性是怎么设置的?答:Spring容器设置的
这个过程就叫控制反转
ClassPathXmlApplicationContext
去看一下底层源码现在,我们彻底不用在程序中去改动了,要实现不同的操作,只需要在xml配置文件中进行修改,一句话理解IOC:对象由Spring来创建,管理,装配!
现在我们来修改上一个案例
具体参考Spring–概述及IOC导论
1、创建beans.xml文件
<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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="mysqlImp" class="com.cgz.dao.UserDaoIMysqlImpl"/>
<bean id="oracleImp" class="com.cgz.dao.UserDaoOracleImpl"/>
<bean id="UserServiceImpl" class="com.cgz.service.UserSerciceImpl">
<property name="userDao" ref="mysqlImp"/>
bean>
beans>
2、测试类
public class MyTest {
public static void main(String[] args) {
//获取ApplicationContext:拿到spring容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//需要什么,就直接get什么!
UserSerciceImpl userServiceImpl =
(UserSerciceImpl) context.getBean("UserServiceImpl");
userServiceImpl.getUser();
}
}
1、使用无参构造创建对象,默认!
2、假设我们要使用有参构造创建对象
一、下标赋值
<bean id="user" class="com.cgz.pojo.User">
<constructor-arg index="0" value="喜羊羊"/>
bean>
二、通过类型创建(不建议使用)
<bean id="user" class="com.cgz.pojo.User">
<constructor-arg type="java.lang.String" value="喜羊羊"/>
bean>
三、直接通过参数名
<bean id="user" class="cn.cgz.pojo.User">
<constructor-arg name="name" value="喜羊羊"/>
bean>
总结:在配置文件加载的时候,容器中管理的对象就已经初始化了!
<alias name="user" alias="newUser"/>
<bean id="user" class="com.cgz.pojo.user" name="user2,u2">bean>
这个import,一般用于团队开发使用,它可以将多个配置文件,导入合并为一个
假设,现在项目有多个人开发,这三个人负责不同类开发,不同的类需要注册在不同的bean中,我们可以利用import将所有人的beans.xml合并为一个总的!
现在汇聚成一个applicationContext.xml
<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>
使用的时候,直接使用总的配置就可以了。
【环境搭建】
public class Address {
private String address;
}
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private String wife;
private Properties info;
}
<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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="address" class="cn.cgz.pojo.Address">
<property name="address" value="西安">property>
bean>
<bean id="student" class="cn.cgz.pojo.Student">
<property name="name" value="张三"/>
<property name="address" ref="address"/>
<property name="books">
<array>
<value>西游记value>
<value>红楼梦value>
<value>三国演义value>
<value>水浒传value>
array>
property>
<property name="hobbys">
<list>
<value>听歌value>
<value>敲代码value>
<value>看电影value>
list>
property>
<property name="card">
<map>
<entry key="身份证" value="1111112312344124"/>
<entry key="银行卡" value="21343241414141"/>
map>
property>
<property name="games">
<set>
<value>LOLvalue>
<value>COCvalue>
<value>BOBvalue>
set>
property>
<property name="wife">
<null/>
property>
<property name="info">
<props>
<prop key="学号">20190525prop>
<prop key="性别">男prop>
<prop key="姓名">小明prop>
props>
property>
bean>
beans>
4、测试类
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student)context.getBean("student");
System.out.println(student.toString());
/**
Student{name='张三',
address=Address{address='西安'},
books=[西游记, 红楼梦, 三国演义, 水浒传],
hobbys=[听歌, 敲代码, 看电影],
card={身份证=1111112312344124, 银行卡=21343241414141},
games=[LOL, COC, BOB],
wife='null',
info={学号=20190525, 性别=男, 姓名=小明}}
*/
}
}
【注意】p命名和c命名空间不能直接使用,需要导入xml约束!
1、还用4.2 的案例,新建一个userbeans.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="user" class="cn.cgz.pojo.User" p:name="狂神" p:age="18"/>
<bean id="user2" class="cn.cgz.pojo.User" c:age="18" c:name="狂神"/>
beans>
2、测试
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
User user = (User)context.getBean("user2", User.class);
System.out.println(user.toString());
}
Spring 容器在初始化一个 Bean 的实例时,同时会指定该实例的作用域。
单例模式和原型模式是最常用的。
<bean id="user2" class="cn.cgz.pojo.User" c:age="18" c:name="狂神" scope="singleton"/>
<bean id="user2" class="cn.cgz.pojo.User" c:age="18" c:name="狂神" scope="prototype"/>
这些只能在web开发中使用到
Spring中有三种配置的方式
新建一个module
1、pojo类
//猫类
public class Cat {
public void shout(){
System.out.println("喵");
}
}
//狗类
public class Dog {
public void shout(){
System.out.println("汪");
}
}
自己生成get/set以及toString方法
//主人类
public class People {
private Cat cat;
private Dog dog;
private String name;
}
2、新建beans.xml
<bean id="cat" class="cn.cgz.pojo.Cat"/>
<bean id="dog" class="cn.cgz.pojo.Dog"/>
<bean id="people" class="cn.cgz.pojo.People">
<property name="name" value="灰太狼丫"/>
<property name="dog" ref="dog"/>
<property name="cat" ref="cat"/>
bean>
beans>
3、测试
public class MyTest {
@Test
public void test1(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people", People.class);
people.getCat().shout();
people.getDog().shout();
}
}
环境搭建成功!
<bean id="cat" class="cn.cgz.pojo.Cat"/>
<bean id="dog" class="cn.cgz.pojo.Dog"/>
<bean id="people" class="cn.cgz.pojo.People" autowire="byName">
<property name="name" value="灰太狼丫"/>
bean>
<bean id="cat" class="cn.cgz.pojo.Cat"/>
<bean id="dog" class="cn.cgz.pojo.Dog"/>
<bean id="people" class="cn.cgz.pojo.People" autowire="byType">
<property name="name" value="灰太狼丫"/>
bean>
小结:
jdk1.5支持注解,Spring2.5就支持注解了!
注解和xml的优缺点
使用注解须知:
<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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/context/spring-aops.xsd">
<context:annotation-config/>
beans>
还在这个案例的基础上修改
1、pojo类
public class People {
@Autowired
private Cat cat;
@Autowired
private Dog dog;
private String name;
}
2、beans.xml
<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"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/context/spring-aops.xsd">
<context:annotation-config/>
<bean id="cat" class="cn.cgz.pojo.Cat"/>
<bean id="dog" class="cn.cgz.pojo.Dog"/>
<bean id="people" class="cn.cgz.pojo.People"/>
beans>
再次运行测试!
@Autowired
直接在属性上使用即可!也可以在set方式上使用!
使用Autowired我们可以不用编写Set方法了,前提是你这个自动装配的属性在IOC(Spring)容器中存在,且符合名字byname!
科普:
//字段标记这个注解,说明这个字段可以为null
@Nullable
//如果显式定义了Autowired属性为false,说明这个对象可以为null,否则不允许为空
@Autowired(required = false)
如果自动装配的环境比较复杂,自动装配无法通过一个注解@Atuowired完成的时候,我们可以使用@Qualifier(value=“xxx”)去配置@Autowired的使用,指定一个唯一的bean对象注入!
<bean id="cat111" class="cn.cgz.pojo.Cat"/>
<bean id="cat222" class="cn.cgz.pojo.Cat"/>
<bean id="dog111" class="cn.cgz.pojo.Dog"/>
<bean id="dog222" class="cn.cgz.pojo.Dog"/>
@Autowired
@Qualifier("cat222")
private Cat cat;
@Autowired
@Qualifier("dog222")
private Dog dog;
@Resource注解
public class People {
@Resource(name = "cat2")
private Cat cat;
@Resource
private Dog dog;
}
小结:
@Resource和@Autowired的区别
<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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="cn.cgz"/>
<context:annotation-config/>
beans>
@Component组件:等价于
@Value:相当于
,可以写在属性上,也可以写在set方法上
@Component
public class User {
public String name;
@Value("小帅比")
public void setName(String name) {
this.name = name;
}
}
@Component的衍生注解
我们在web开发中,会按照mvc三层架构分层!
这四个注解功能都是一样的,都是代表将某个类注册到Spring中,装配Bean
- @Autowired:自动装配,先通过类型,找不到再通过名字
如果Autowired不能唯一自动装配上属性,则需要通过@Qualifier(value="xxx")
- @Nullable:字段标记了这个注解,说明这个字段可以为null
- @Resource:自动装配,先通过名字,再通过类型
@Component
@Scope("prototype") //作用域
public class User {
public String name;
@Value("小帅比")
public void setName(String name) {
this.name = name;
}
}
和前面5、Bean的作用域一个道理!
@Component
@Scope("prototype") //作用域
public class User {
public String name;
@Value("小帅比")
public void setName(String name) {
this.name = name;
}
}
6.小结
xml与注解:
xml与注解的最佳实践:
<context:component-scan base-package="cn.cgz"/>
<context:annotation-config/>
我们现在要完全不使用Spring的xml配置了,全权交给Java来做!
JavaConfig是Spring的一个子项目,在Spring4之后,它成为了一个核心功能!
测试
@Component
public class User {
@Value("光头强")
private String name;
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
@Component:这个类被注册到spring容器中
@Configuration
@ComponentScan("cn.cgz.pojo")
@Import(BeanConfig2.class)
public class BeanConfig {
@Bean
public User getUser(){
return new User();//要注入的bean对象
}
}
@Configuration
public class BeanConfig2 {
}
@Configuration:添加了这个注解的类就相对于我们之前的xml配置文件,这个也会被spring托管,注册到容器中
@ComponentScan:扫描包
@Import:把两个类引成一个类
@Bean:注册一个bean,就相当于xml中写的一个bean标签;这个方法的名字,就相对于bean标签中的id属性;这个方法的返回值,就相当于bean标签中的class属性。
public class MyTest {
public static void main(String[] args) {
ApplicationContext context =
new AnnotationConfigApplicationContext(BeanConfig.class);
User user = (User)context.getBean("getUser");
System.out.println(user.toString());
}
}
这种纯Java的配置方式,在SpringBoot中随处可见!
学习AOP之前需要先熟悉代理模式!
AOP(Aspect Oriented Programming)意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
提供声明式事务;允许用户自定义切面
以下名词需要了解下:
名称 | 说明 |
---|---|
Joinpoint(连接点) | 指那些被拦截到的点,在 Spring 中,可以被动态代理拦截目标类的方法。 |
Pointcut(切入点) | 指要对哪些 Joinpoint 进行拦截,即被拦截的连接点。 |
Advice(通知) | 指拦截到 Joinpoint 之后要做的事情,即对切入点增强的内容。 |
Target(目标) | 指代理的目标对象。 |
Weaving(织入) | 指把增强代码应用到目标上,生成代理对象的过程。 |
Proxy(代理) | 指生成的代理对象。 |
Aspect(切面) | 切入点和通知的结合。 |
横切关注点:跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
通知(Advice)其实就是对目标切入点进行增强的内容,Spring AOP 为通知(Advice)提供org.aopalliance.aop.Advice 接口。
org.springframework.aop.MethodBeforeAdvice
: 在方法之前自动执行的通知称为前置通知,可以应用于权限管理等功能。org.springframework.aop.AfterReturningAdvice
: 在方法之后自动执行的通知称为后置通知,可以应用于关闭流、上传文件、删除临时文件等功能。org.aopalliance.intercept.MethodInterceptor
: 在方法前后自动执行的通知称为环绕通知,可以应用于日志、事务管理等功能。org.springframework.aop.ThrowsAdvice
:在方法抛出异常时自动执行的通知称为异常通知,可以应用于处理异常记录日志等功能。org.springframework.aop.IntroductionInterceptor
:在目标类中添加一些新的方法和属性,可以应用于修改旧版本程序(增强类)。使用AOP织入,需要导入一个依赖包!
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.4version>
dependency>
方式一:使用原生spring API接口
1、接口
public interface UserService {
public void add();
public void delete();
public void update();
public void select();
}
2、实现类
public class UserServiceImpl implements UserService {
@Override
public void add() {
System.out.println("增加一个用户");
}
@Override
public void delete() {
System.out.println("删除一个用户");
}
@Override
public void update() {
System.out.println("修改一个用户");
}
@Override
public void select() {
System.out.println("查询一个用户");
}
}
3、前置通知
public class Log implements MethodBeforeAdvice {
//method:要执行的目标对象的方法
//orgs:参数
//target:目标对象
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
}
}
4、后置通知
public class AfterLog implements AfterReturningAdvice {
//returnValue:返回值
public void afterReturning(Object returnValue, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("执行了" + method.getName() + "方法,返回结果为:" + returnValue);
}
}
5、application.xml
<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"
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">
<bean id="userService" class="cn.cgz.service.UserServiceImpl"/>
<bean id="log" class="cn.cgz.log.Log"/>
<bean id="afterLog" class="cn.cgz.log.AfterLog"/>
<aop:config>
<aop:pointcut id="pointcut"
expression="execution(* cn.cgz.service.UserServiceImpl.*(..))"/>
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
aop:config>
beans>
expression表达式详解
6、测试
public class MyTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) context.getBean("userService");
userService.add();
}
}
方式二:自定义类实现AOP
1、在方式一的基础上,新建一个DiyPointCut类
public class DiyPointCut {
public void before(){
System.out.println("===========方法执行前===========");
}
public void after(){
System.out.println("=============方法执行===========");
}
}
2、application.xml
<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"
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">
<bean id="userService" class="cn.cgz.service.UserServiceImpl"/>
<bean id="diy" class="cn.cgz.dy.DiyPointCut"/>
<aop:config>
<aop:aspect ref="diy">
<aop:pointcut id="point"
expression="execution(* cn.cgz.service.UserServiceImpl.*(..))"/>
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
aop:aspect>
aop:config>
beans>
方式三:使用注解方式实现AOP
1、在方式一的基础上新建一个AnnotationPointCut类
//方式三:使用注解方式实现aop
@Aspect//标注这个类是一个切面
public class AnnotationPointCut {
@Before("execution(* cn.cgz.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("=======方法执行前==========");
}
@After("execution(* cn.cgz.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("=======方法执行后==========");
}
//在环绕增强中,我们可以给定一个参数,代表我们要处理切入的点
@Around("execution(* cn.cgz.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
//获得签名
Signature signature = jp.getSignature();
System.out.println("signatrue:" + signature);
//执行方法
Object proceed = jp.proceed();
System.out.println("环绕后");
}
}
2、application.xml
<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"
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">
<bean id="userService" class="cn.cgz.service.UserServiceImpl"/>
<bean id="annotationPointCut" class="cn.cgz.dy.AnnotationPointCut"/>
<aop:aspectj-autoproxy/>
beans>
结果如下: