目录
spring案例
1.新建一个普通java文件
2.引入spring的jar包
3.创建一个普通类,类中创建普通方法
4.创建一个配置文件或者通过注解来创建的那个对象
(1)spring配置文件使用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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置user对象创建-->
<bean id="test" class="comm.Test"></bean><!--无参构造创建对象-->
</beans>
5.测试代码编写
public class TestSpring {
@Test
public void test(){
//加载配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//获取配置文件创建的对象
User user = context.getBean("user",User.class);//万一这么多对象,你怎么知道是那个user,后面的参数就告诉你是User类型的对象
user.add();
}
}
spring优点
spring理念:使现有的技术更容易使用,本身是一个大杂烩,整合了现有技术框架。
弊端:发展太久之后,违背了原来的理念!配置十分繁琐。人称:“配置地狱”
spring是一个开源的免费的框架(容器)!
spring是一个轻量级,非入侵式框架!
控制反转(IOC):把创建对象交给spring管理,
面向切面编程(AOP):不修改源代码进行功能增强
支持事务处理,对框架整合的支持
总结:spring就是一个轻量级的控制反转(IOC)和面向切面编程的框架(AOP)的框架。
组成
spring Boot:一个快速开发的脚手架,基于springBoot可以快速开发一个单个微服务
spring cloud:springcloud是基于spring boot实现的。
引入基础jar包
beans,core,context,expression
IOC理论
1.什么是IOC?
(1).把对象创建和对象之间的调用过程交给spring进行管理
(2).使用IOC目的:为了降低耦合度
(3).入门案例就是IOC实现
2.IOC的底层原理使用技术
(1)xml配置文件
(2)dom4解析xml
(3)工厂设计模式
(4)反射
第一步 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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置user对象创建-->
<bean id="test" class="comm.Test"></bean>
</beans>
第二步 有service类和dao类,创建的工厂类
class userFactory{
public static UserDao getDao(){
String classvalue = class属性值;//xml解析
Class clazz = Class.forName(classvalue);
return (userDao)clazz.newInstance();
}
}
3.IOC接口
(1).IOC思想基于IOC容器完成,IOC容器底层就是对象工厂
(2).Spring提供IOC容器实现的两种方式(两个接口)
beanFactory:IOC容器基本实现,是Spring内部的使用接口,不提供给开发人员使用,但是也可以用。加载配置文件的时候不会创建对象,在获取对象(使用)才去创建对象
ApplicationContest:是beanFactory接口的子接口,提供了更加强大的功能,一般由开发人员使用。加载配置文件时候就创建了对象
ApplicationContest有两个实现类:一个是FileSystemSmlApplicationContest(系统盘路径),另一个是ClasspathXmlApplicationContest(src路径)。
IOC容器--Bean管理xml的方式
什么是bean管理?
Bean管理指的两个操作:
(1)Spring创建对象
(2)Spring注入属性
IOC操作Bean管理两种方式(创建类和注入属性的方式)
IOC的配置文件(xml)方式
xml方式创建对象:创建对象的时候默认是无参构造,因为必须有无参构造方法
在spring的配置文件中,使用Bean标签,在标签里面加入对应属性,就可以实现这个对象创建。
标签属性:
id:获取对象的那个唯一的标识
class:创建对象所在那个类的一个全路径
name:name其实跟id标签效果相同,只是name可以加入特殊符号,而id不行。
<bean id="user" class = "com.atguigu.spring5.User"></bean>
xml方式注入属性:
DI:依赖注入,就是注入属性,要在创建对象的基础之上完成
第一种注入方式:原始方法,利用set方法注入。
/*
* 演示set方法注入属性
* */
public class Book {
//创建属性
private String bname;
private String bauthor;
//对应的set方法
public void setBname(String bname) {
this.bname = bname;
}
public void setBauthor(String bauthor) {
this.bauthor = bauthor;
}
//本来在main方法调用set方法就好了。现在去Spring配置文件配置对象创建,配置属性注入。
/*public static void main(String[] args) {
Book book = new Book();
book.setBname("ssss");
}*/
}
set方法--------property
<?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">
<!--配置Book对象创建-->
<bean id="book" class = "com.atguigu.spring5.Book">
<!--set方法注入属性,使用property完成属性注入-->
<property name="bname" value="辟邪剑法"></property>
<property name="bauthor" value="林平之"></property>
</bean>
</beans>
public class TestDemo {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Book book = context.getBean("book",Book.class);
book.print();
}
}
第二种注入方式:有参构造注入
public class Order {
private String oname;
private String address;
public Order(String oname, String address) {
this.oname = oname;
this.address = address;
}
public void print(){
System.out.println(oname+":"+address);
}
}
有参构造--------------constructor-arg
<?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">
<bean id="order" class="Order">
<constructor-arg name="oname" value="洗发水"></constructor-arg>
<constructor-arg name="address" value="长沙"></constructor-arg>
<constructor-arg index="0" value="ss"></constructor-arg>//代表有参构造第一个参数
</bean>
</beans>
public class TestDemo {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
Order order = context.getBean("order",Order.class);
order.print();
}
}
p名称空间注入
1.使用p名称空间注入,可以简化基于xml配置方式。
第一步 添加p名称空间在配置文件中
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
第二步 进行属性注入
<!--配置Book对象创建-->
<bean id="book" class = "Book" p:bname="九阳神功" p:bauthor="无名氏">
</bean>
</beans>
xml注入其他类型属性 。比如字面量为null或者含有一些特殊符号。
意思就是把address属性设置为null
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置Book对象创建-->
<bean id="book" class = "Book">
<property name="bname">
<null/>
</property>
<property name="bauthor">
<null/>
</property>
</bean>
</beans>
把address属性设置成特殊符号
<?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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--配置Book对象创建-->
<bean id="book" class = "Book">
<property name="bname">
<value><![CDATA[......]]></value>
</property>
<property name="bauthor">
<null/>
</property>
</bean>
</beans>
注入属性---外部bean
使用场景:创建了两个类service和dao类,在service调用dao里面的方法,在spring配置文件中进行配置。
public class UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void test(){
System.out.println("add.....");
}
public void add(){
System.out.println("service add..........");
userDao.update();
}
}
public class UserDaoiml implements UserDao{
@Override
public void update() {
System.out.println("dao update.....");
}
}
<?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">
<!--创建对象-->
<bean id="userservice" class="service.UserService">
<!--通过set方法来注入属性-->
<!--name属性:类里面的属性名称
ref属性:创建userdao对象bean标签的id值-->
<property name="userDao" ref="userdaoiml"></property>
</bean>
<bean id="userdaoiml" class="dao.UserDaoiml"></bean>
</beans>
public class Bean1Test {
@Test
public void test(){
//加载配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("bea2.xml");
//获取配置文件创建的对象
UserService userService = context.getBean("userservice",UserService.class);
userService.add();
}
}
(1)一对多关系,部门和员工。
(2)在实体类中表示一对多关系。
注入属性--内部bean和级联赋值
public class Emp {
private String ename;
private String gender;
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
public void add(){
System.out.println(ename+":"+
gender+":"+
dept);
}
}
package bean;
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
@Override
public String toString() {
return "Dept{" +
"dname='" + dname + '\'' +
'}';
}
}
内部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">
<!--创建对象-->
<bean id="emp" class="bean.Emp">
<!--注入属性-->
<!--id:是创建对象的名字
class:是创建对象的类包
name:是要注入的属性
value:是要注入的属性值,不包括自定义类
ref:是要注入的属性是自定义类,而且是一个对象,是要注入一个外部bean,因此我们需要注入一个对象,因此我们把外部bean的id给ref。其实ref就是S s = new S();的new S()。外部的对象用ref引入-->
<property name="ename" value="李祖德"></property>
<property name="gender" value="男"></property>
<!--<property name="dept" ref="dept"></property>-->
<property name="dept">
<bean id="dept" class="bean.Dept">
<property name="dname" value="it"></property>
</bean>
</property>
</bean>
</beans>
级联赋值
第一种:
<?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">
<!--创建对象-->
<!--级联赋值-->
<bean id="emp" class="bean.Emp">
<property name="ename" value="李祖德"></property>
<property name="gender" value="男"></property>
</bean>
<bean id="dept" class="bean.Dept">
<property name="dname" value="ll"></property>
</bean>
</beans>
第二种:
<?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">
<!--创建对象-->
<!--级联赋值-->
<bean id="emp" class="bean.Emp">
<property name="ename" value="李祖德"></property>
<property name="gender" value="男"></property>
<property name="dept" ref="dept"></property>
<property name="dept.dname" value="ss"></property>
</bean>
<bean id="dept" class="bean.Dept">
<property name="dname" value="ll"></property>
</bean>
</beans>
public class beanTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean8.xml");//只能是在scr文件下,在其他文件下会报错
Emp emp = context.getBean("emp" ,Emp.class);
emp.add();
}
}
xml注入集合属性:
1.注入数组类型属性
2.注入List集合属性
3.注入Map集合类型属性
(1) 创建类,定义数组,list,Map,set类型属性,生成对应set方法
public class Stu {
private String[] courses;
private List<String> list;
private Map<String,String> map;
private Set<String> set;
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public void setSet(Set<String> set) {
this.set = set;
}
public void add(){
System.out.println(Arrays.toString(courses));
System.out.println(list);
System.out.println(map);
System.out.println(set);
}
}
(2)在Spring的配置文件中进行配置 ,创建对象,注入属性
<?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">
<bean id="stu" class="collectiontype.Stu">
<property name="courses">
<array>
<value>java</value>
<value>sql</value>
</array>
</property>
<property name="list">
<list>
<value>张三</value>
<value>小三</value>
</list>
</property>
<property name="map">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="SQL" value="sql"></entry>
</map>
</property>
<property name="set">
<set>
<value>maysql</value>
<value>redius</value>
</set>
</property>
</bean>
</beans>
(3).测试类
public class SpringTest {
@Test
public void test(){
ApplicationContext contest = new FileSystemXmlApplicationContext("E:\\Bean02\\src\\collectiontype\\bean1.xml");
Stu stu = contest.getBean("stu",Stu.class);
stu.add();
}
}
4.在集合里面设置对象类型值
(1) 创建类,定义数组,list,Map,set类型属性,生成对应set方法
public class Stu {
private String[] courses;
private List<String> list;
private Map<String,String> map;
private Set<String> set;
//学生所学多门课程
private List<Course> courselist;
public void setCourselist(List<Course> courselist) {
this.courselist = courselist;
}
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public void setSet(Set<String> set) {
this.set = set;
}
public void add(){
System.out.println(Arrays.toString(courses));
System.out.println(list);
System.out.println(map);
System.out.println(set);
System.out.println(courselist);
}
}
集合里面设置的类
public class Course {
private String cname;
public void setCname(String cname) {
this.cname = cname;
}
@Override
public String toString() {
return "Course{" +
"cname='" + cname + '\'' +
'}';
}
}
(2)在Spring的配置文件中进行配置 ,创建对象,注入属性
<?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">
<bean id="stu" class="collectiontype.Stu">
<property name="courses">
<array>
<value>java</value>
<value>sql</value>
</array>
</property>
<property name="list">
<list>
<value>张三</value>
<value>小三</value>
</list>
</property>
<property name="map">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="SQL" value="sql"></entry>
</map>
</property>
<property name="set">
<set>
<value>maysql</value>
<value>redius</value>
</set>
</property>
<!--注入list集合类型,但是他的值是一个对象-->
<property name="courselist">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
<ref bean="course3"></ref>
</list>
</property>
</bean>
<!--创建多个course对象-->
<bean id="course1" class="collectiontype.Course">
<property name="cname" value="数学"></property>
</bean>
<bean id="course2" class="collectiontype.Course">
<property name="cname" value="语文"></property>
</bean>
<bean id="course3" class="collectiontype.Course">
<property name="cname" value="英语"></property>
</bean>
</beans>
(3).测试类
public class SpringTest {
@Test
public void test(){
ApplicationContext contest = new FileSystemXmlApplicationContext("E:\\Bean02\\src\\collectiontype\\bean1.xml");
Stu stu = contest.getBean("stu",Stu.class);
stu.add();
}
}
5.把集合注入部分提取出来,让他成为一个公共部分,让其他对象也可使用。如果没有提取出来只可以在当前bean标签使用,而其他的bean标签不能使用。
(1)在spring配置文件中引入名称空间util
Book类:
public class Book {
private List<String> list;
public void setList(List<String> list) {
this.list = list;
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:util = "http://www.springframework.org/schema/util"
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
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<!--引入util-->
<!--把beans改为util-->
</beans>
(2)使用util标签完成list集合注入提取
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:util = "http://www.springframework.org/schema/util"
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
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
<!--提取list集合类型属性注入-->
<util:list id="booklist">
<value>易筋经</value>
<value>九阴真经</value>
<value>降龙十八掌</value>
</util:list>
<!--提取list集合类型属性注入使用-->
<bean id="book" class="collectiontype.Book">
<property name="list" ref="booklst"></property>
</bean>
</beans>
IOC操作Bean管理(FactoryBean)
1.Spring有两种类型的bean,一种普通的bean,另外一种bean是FactoryBean(工厂Bean)。
2.普通bean在Spirng配置文件中定义bean类型就是返回类型
3.工厂bean:在配置文件定义的bean类型和返回类型不一样
第一步 创建类,让这个类作为工厂bean,实现FactoryBean
第二步 实现接口里面的方法,在实现的方法中定义返回bean类型
bean的作用域:
1.在Spring里面,设置创建bean实例是单实例还是多实例,任何设置呢?
在Spring里面有一个属性设置是单实例还是多实例(Scope)
scope属性值 第一个值 默认值 singleton表示单实例对象
第二个值 prototype表示多实例对象
sington与prototype区别
第一:singleton是单实例,prototype是多实例
第二:设置scope值是singleton时候,加载spring配置文件时候就会创建单实例对象
设置scope值是prototype时候,不是加载Spring配置文件时候创建对象,而在调用getbean方法时候去创建多实例对象。
2.在Spring里面,默认情况下,bean是一个单实例对象
如果是多实例那么每一次获取对象应该都是不同的对象,然而确实是单实例。
public class FactoryBean {
@Test
public void test(){
ApplicationContext context = new FileSystemXmlApplicationContext("E:\\zw\\src\\bean.xml");
User user1 = context.getBean("user",User.class);
User user2 = context.getBean("user",User.class);
System.out.println(user1);//user1与user2的地址相同
System.out.println(user2);
}
}
bean的生命周期:
1.什么是生命周期?
从对象创建到销毁的过程
2.bean的生命周期
(1)通过构造器创建bean实例(无参数构造)
(2)为bean的属性设置值和对其他bean的引用(调用set方法)
(3)把bean的实例传给bean的后置处理器的方法(必须配置了后置处理器)
postProcessBeforeInitialization
(3)调用bean的初始化方法(需要进行配置初始化方法)
(5)把bean实例传递给bean后置处理器的方法(必须配置了后置处理器)
postProcessAfterInitialization
(4)bean可以使用(获取到了创建的对象)
(5)当容器关闭时候,调用bean的销毁方法(需要进行配置销毁方法)
加上bean的后置处理器:bean生命周期有七步
演示添加后置处理器效果
(1)创建类,实现BeanPostProcessor接口,创建后置处理器
public class MyBeanPost implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("初始化之前执行的方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("初始化之后执行的方法");
return bean;
}
}
(2)配置后置处理器
<?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">
<bean id="orders" class="Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机"></property>
</bean>
<!--配置后置处理器:当你添加后置处理器之后,所有的bean都将添加后置处理器,处理器类中
有两个方法,一个在初始化之前执行,一个在初始化之后执行-->
<bean id="myBeanPost" class="MybeanPost"></bean>
</beans>
xml自动装配
自动装配:注入属性通过一些标签比如Property来手动装配
<property name="oname" value="手机"></property>
(1)根据指定装配规则(属性名或者属性类型),Spring自动将配置的属性值进行注入
(2)演示自动装配过程
<?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">
<bean id="dept" class="Dept"></bean>
<bean id="emp" class="Emp" autowire="byName"></bean>
<!--autowire标签属性,自动装配
byName根据属性名称注入,注入值bean的id和类属性名称一样
bytype根据属性类型注入,
加载配置文件,根据配置文件找到那个类的对象,然后创建了对象之后发现有自动装配,如果是根据名字就要求bean的id和类属性名称一样。如果是根据类型,就要求同一种类型的对象不能创建多个在bean.xml
文件中-->
</beans>
引入外部属性文件配置数据库连接池
不引入外部文件属性配置数据库连接池
<?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">
<bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
</beans>
引入外部属性文件配置数据库连接池
(1)创建外部属性文件,.properties格式文件,写数据库信息
prop.driverclass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.username=root
prop.password=root
(2)把外部properties属性引入到Spring配置文件中
*引入context名称空间
<?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:p="http://www.springframework.org/schema/p"
xmlns:util="http://www.springframework.org/schema/util"
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/util http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:JDBC.properties"></context:property-placeholder>
<!--配置连接池:使用spring里面的表达式${}-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverclass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.username}"></property>
<property name="prop.password" value="${prop.password}"></property>
</bean>
</beans>
IOC的注解方式
注解方式创建对象:
spring针对Bean管理中创建对象提供注解:
(1)@component
(2)@service
(3)@controller
(4)@repository
上面四个注解功能是一样的,都可以用来创建对象
基于注解进行实现对象创建
(1)引入依赖
(2)开启组件扫描:告诉Spring容器,在那个类里面要加上注解,有创建对象的注解就创建对象。还要指定区域,到底去哪扫描。
<?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: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/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.at.spring"></context:component-scan>
</beans>
开启组件扫描细节问题:
在那个包下面开启组件扫描
<context:component-scan base-package="com.at.spring"></context:component-scan>
在那个包下开启组件扫描 ,没有使用默认的扫描内容,而是扫描的是注解类型,那种类型的注解
<context:component-scan base-package="com.at.spring" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
</context:component-scan>
在那个包下开启组件扫描 ,没有使用默认的扫描内容,而是扫描的是注解类型,非那种类型的注解
<context:component-scan base-package="com.at.spring">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
</context:component-scan>
(3)创建类,在类上面添加创建对象注解
package com.at.spring.service;
import org.springframework.stereotype.Component;
@Component(value = "userService")//bean id="userService" class=".."
public class UserService {
public void add(){
System.out.println("Service add...........");
}
}
注解方式注入属性:
(1)@AutoWired:根据属性类型自动装配
(2)@Qualifer:根据属性名称进行注入
(3)@Resource:可以根据类型注入,可以根据名称注入
(4)@Value:注入普通类型的属性
第一步:把service和dao对象创建,在service和dao类添加创建对象注解
第二步:在service注入dao对象,在service类型添加dao类型属性,在属性上面使用注解
@autoWire的使用
@Repository
public class UserDaoiml implements UserDao {
@Override
public void add() {
System.out.println("add");
}
}
@Repository
public class UserService {
@Autowired
//不需要加入set方法
private UserDao userDao;
public void println(){
System.out.println("service add........");
userDao.add();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.at"></context:component-scan>
</beans>
public class SpringTest {
@Test
public void test(){
ApplicationContext context = new FileSystemXmlApplicationContext("E:\\untitled\\src\\com\\at\\Spring\\bean.xml");
UserService userService = context.getBean("userService",UserService.class);
System.out.println(userService);
userService.println();
}
}
@Qualifer的使用:要与Autowire联合使用。
Autowire根据类型注入,但是一个类型可能有多个实现类,因此还需要加上对象名
@Repository
public class UserService {
@Autowired
@Qualifier(value = "userDaoiml")
//不需要加入set方法
private UserDao userDao;
public void println(){
System.out.println("service add........");
userDao.add();
}
}
@Resource可以根据类型注入:
@Repository
public class UserService {
@Resource//根据类型注入
private UserDao userDao;
public void println(){
System.out.println("service add........");
userDao.add();
}
}
也可以根据名称注入
@Repository
public class UserService {
@Resource(name = "userDaoiml")//根据名称注入
private UserDao userDao;
public void println(){
System.out.println("service add........");
userDao.add();
}
}
@value:注入普通属性
@Repository
public class UserService {
@Resource(name = "userDaoiml")//根据名称注入
private UserDao userDao;
@Value(value = "root")
private String username;
public void println(){
System.out.println("service add........");
userDao.add();
}
@Override
public String toString() {
return "UserService{" +
"userDao=" + userDao +
", username='" + username + '\'' +
'}';
}
}
完全注解开发:
(1)创建配置类,替代xml配置文件。
@Configuration//说明此类是Spring的配置类,代替xml配置文件
@ComponentScan(basePackages = "com.at")//组件扫描类似<context:component-scan base-package="com.at.spring"></context:component-scan>
public class SpringConfigure {
}
(2)编写测试类
@Test
public void test1(){
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfigure.class);//加载配置类
UserService userService = context.getBean("userService",UserService.class);
System.out.println(userService);
userService.println();
System.out.println(userService);
}
AOP
什么是AOP
AOP(面向切面编程):利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各个部分之间的耦合度降低,提高程序的可重用性,同时提高开发效率。
通俗来讲:不通过修改源代码方式,在主干功能里面添加新的功能。而是新建一个功能模块,把这个功能模块配置到主干功能中去。
底层原理
AOP底层使用动态代理
(1)动态代理有两种情况
第一种:有接口情况,使用JDK动态代理
第二种:没有接口情况,使用CGLIB动态代理
AOP(JDK动态代理)
1.使用JDK动态代理,使用proxy类里面的方法创建动态代理
(1)调用newProxyInstance方法返回一个接口实现类代理对象
方法有三个参数:
第一参数,类加载器
第二参数,增强方法所在的类,这个类实现的接口,支持多个接口。
第三参数,实现这个接口InvocationHandler,创建代理对象,写增强的方法。
(2).JDK动态代理代码
(1)创建接口,定义方法。
public interface UserDao {
int add(int a,int b);
String update(String id);
}
(2)创建接口实现类,实现方法
public class UserDaoIml implements UserDao{
@Override
public int add(int a, int b) {
return a+b;
}
@Override
public String update(String id) {
return id;
}
}
(3).使用proxy类创建接口代理对象
public class JDKproxy {
public static void main(String[] args) {
//创建接口实现类的代理对象
Class[] interfaces = {UserDao.class};
UserDaoIml userDaoIml = new UserDaoIml();
UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKproxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDaoIml));
int add = userDao.add(1,2);
System.out.println(add);
}
}
class UserDaoProxy implements InvocationHandler{
//1.把创建的是谁的代理对象,把谁传递过来
//有参数构造传递
Object object;
public UserDaoProxy(Object object){
this.object = object;
}
//增强的逻辑写道invoke方法中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法之前执行
System.out.println("方法之前执行................"+ method.getName()+":传递参数."+ Arrays.toString(args));
//被增强的方法执行
Object res = method.invoke(object,args);
//方法之后
System.out.println("方法之后执行。。。。"+object);
return res;
}
}
AOP术语
1.连接点
2.切入点
3.通知(增强)
4.切面
AOP的操作(准备工作)
1.在Spring框架中一般基于AspectJ实现AOP操作
(1)什么是Aspectj:它不是Spring的组成部分,独立的AOP框架。一般把AspectJ和Spring框架一起使用,进行AOP操作。
2.基于AspectJ实现AOP操作
(1)基于xml配置文件实现
(2)基于注解方式实现
3.在项目过程里面引入AOP相关依赖
4.切入点表达式
(1)切入点表达式作用:知道对那个类里面的那个方法进行增强
(2)语法结构:
execution ([权限修饰符] [返回类型] [类的全路径] [方法名称])
举例1:对com.at.dao.BookDao类里面的add进行增强
execution(*com.at.dao.BookDao.add(..))
*代表任一一个权限修饰符,返回值类型可以省略,类的全路径然后.方法名,方法名后面括号加上(..)代表参数列表
举例2:对com.at.dao.BookDao类里面所有的方法进行增强
execution(*com.at.dao.BookDao.*(..))
举例3:对com.at.dao包里所有类,类里面所有的方法进行增强
execution(*com.at.dao.*.*(..))
AOP操作(注解)
1.创建类,在类里面定义方法
2.创建增强类:对这个方法写增强,我们对这个方法编写什么增强逻辑
(1)在增强类里面,创建方法,让不同的方法代表不同的通知类型
3.进行通知的配置
(1)在spring配置文件中,开启注解扫描
(2)使用注解创建user和userproxy对象
(3)在增强类上面添加注解@Aspect,用这个类生成一个代理对象
(4)在spring配置文件中开启生成代理对象,配置切面。
4.配置不同类型的通知
(1)在增强类里面,在作为通知方法上面添加通知类型注解,使用切入点表达式配置
//被增强的类
@Component
public class User {
public void add(){
System.out.println("add......");
}
}
@Aspect
@Component
public class UserProxy {
//前置通知
@Before(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
public void before(){
System.out.println("before......");
}
}
<?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"
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/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--开启组件扫描-->
<context:component-scan base-package="com.atguigu.spring5.AOPAnnocation"></context:component-scan>
<!--查看类中是否有@Aspect的注解,如果有就开启Aspect生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
@Aspect
@Component
public class UserProxy {
//前置通知
@Before(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
public void before(){
System.out.println("before......");
}
//最终通知,在方法之后执行,相当于finlly,反正最后一定会执行,出异常了也会执行
@After(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
public void after(){
System.out.println("after.......");
}
//后置通知,在返回值之后执行,出异常了就不执行
@AfterReturning(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
public void afterReturnning(){
System.out.println("afterReturnning.....");
}
//环绕通知
@Around(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前");
proceedingJoinPoint.proceed();//被增强的方法执行
System.out.println("环绕之后");
}
//异常通知,只有当add方法内有异常才会执行
@AfterThrowing(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
public void afteraround(){
System.out.println("AfterThrowing");
}
}
5.公共切入点抽取
相同的切入点抽取
//增强的类
@Aspect
@Component
public class UserProxy {
//相同切入点抽取
@Pointcut(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
public void pointcut(){
}
//前置通知,下面的注解其实就是增强到那个方法上去
@Before(value = "pointcut()")
public void before(){
System.out.println("before......");
}
//最终通知,在方法之后执行,相当于finlly,反正最后一定会执行,出异常了也会执行
@After(value = "pointcut()")
public void after(){
System.out.println("after.......");
}
//后置通知,在返回值之后执行,出异常了就不执行
@AfterReturning(value = "pointcut()")
public void afterReturnning(){
System.out.println("afterReturnning.....");
}
//环绕通知
@Around(value = "pointcut()")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前");
proceedingJoinPoint.proceed();//被增强的方法执行
System.out.println("环绕之后");
}
//异常通知,只有当add方法内有异常才会执行
@AfterThrowing(value = "pointcut()")
public void afteraround(){
System.out.println("AfterThrowing");
}
}
6.有多个增强类多同一个方法进行增强,设置增强类优先级
(1)在增强类上面添加注解@order(数字类型值),数字越小,优先级越高。
@Component
@Aspect
@Order(value = 1)
public class PersonProxy {
@After(value = "execution(* com.atguigu.spring5.AOPAnnocation.User.add(..))")
public void after(){
System.out.println("person afetr........");
}
}
AOP操作(AspectJ配置文件)
1.创建两个类,增强类和被增强类,创建方法。
2.在Spring配置文件中创建两个类对象
3.在spring配置文件中配置切入点
<?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"
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="book" class="com.atguigu.spring5.Aspectjxml.Book"></bean>
<bean id="bookProxy" class="com.atguigu.spring5.Aspectjxml.BookProxy"></bean>
<!--配置aop增强-->
<aop:config>
<!--配置切入点-->
<aop:pointcut id="p" expression="execution(* com.atguigu.spring5.Aspectjxml.Book.buy(..))"/>
<!--配置切面-->
<aop:aspect ref="bookProxy">
<!--增强作用具体在那个方法上-->
<aop:before method="before" pointcut-ref="p" ></aop:before>
</aop:aspect>
</aop:config>
</beans>
SSM整合
参考雷神的整合案例十分详细,个人建议先进行整合再对ssm系统学习,这样可以更加容易的学习