1. IOC创建对象

1.HelloSpring环境搭建(第一个Spring程序)

1.maven下载pom依赖

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"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd">
​<bean id="hello" class="com.xiaofeng.pojo.HelloSpring"><!--注入变量值--><property name="str" value="你好Spring"></property>
​</bean>
​
​
</beans>

3.创建实体类

4.测试

   
//引入上下文
ApplicationContext context = new ClassPathXmlApplicationContext( "BeanSpring.xml");
//获取对象HelloSpring bean = (HelloSpring)context.getBean("hello");

2. 有参构造bean的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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="hello" class="com.xiaofeng.pojo.HelloSpring"><constructor-arg index="0" value="你好"></constructor-arg>​</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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="hello" class="com.xiaofeng.pojo.HelloSpring"><constructor-arg ref="" value=""></constructor-arg>
​
​</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/beanshttps://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="hello" class="com.xiaofeng.pojo.HelloSpring"><constructor-arg name="str" value="你好"></constructor-arg>
​
​</bean>
​
​
</beans>

2. Spring配置文件解析

别名

    <bean id="hello" class="com.xiaofeng.pojo.HelloSpring"><constructor-arg name="str" value="你好"></constructor-arg></bean>
<!--别名--><alias name="hello" alias="u1"></alias>

配置

<!-- 
name 别名 比alias更强大,可以使用多种分隔符起多个别名
id 对象名
class 类全限定名
-->
<bean id="hello" class="com.xiaofeng.pojo.HelloSpring" name="u1,u2,u3;u4"><constructor-arg name="str" value="你好"></constructor-arg>
</bean>

import

  <!--导入其他的bean 一般在项目中用于汇总-->
<import resource="BeanSpring.xml"></import><import resource="BeanSpring2.xml"></import><import resource="BeanSpring3.xml"></import>

3. 依赖注入

3.1 构造器注入

 <bean id="hello" class="com.xiaofeng.pojo.HelloSpring"><constructor-arg name="str" value="你好"></constructor-arg></bean>

3.2 Set注入

依赖注入:依赖于容器,将bean对象属性值注入到对象中(就是Spring容器代理操作对象)

环境搭建

1. 测试对象引用bean创建

package com.xiaofeng.pojo;public class Address {private String address;public void setAddress(String address) {this.address = address;}public String getAddress() {return address;}@Overridepublic String toString() {return "Address{" +"address='" + address + '\'' +'}';}
}

2. 真是测试对象

    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;

3. xml文件创建

<bean id="Address" class="com.xiaofeng.pojo.Address"></bean>
<bean id="student" class="com.xiaofeng.pojo.Student">
<!--普通值注入--><property name="name" value="段晓风"></property>
</bean>

4. 测试类

import com.xiaofeng.pojo.Student;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test {@org.junit.Testpublic void Test(){ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");Student student = (Student)context.getBean("student");String name = student.getName();System.out.println(name);}
}

5. 完善set映射

<bean id="student" class="com.xiaofeng.pojo.Student"><!--普通值注入--><property name="name" value="段晓风"></property><property name="address" ref="Address"></property><property name="books"><!--数组类型属性--><array><value>悲惨世界</value><value>天狗</value></array></property><property name="card"><!--map类型属性--><map><entry key="身份证" value="411528"></entry><entry key="学生证" value="5641"></entry></map></property><property name="games"><!--set类型属性--><set><value>lol</value><value>阴阳师</value></set></property><property name="hobbys"><!--list类型属性--><list><value>看电影</value><value>听歌</value></list></property><property name="info"><!--properties文件类型属性--><props><prop key="学号">0000</prop><prop key="url">111</prop></props></property><property name="wife"><!--null--><null></null></property></bean>

6. 扩展p c标签快捷注入

xmlns:p="http://www.springframework.org/schema/p"<!--初始写法--><property name="address" ref="address"></property><property name="name" value="之秋"></property><!--省略了property 直接在bean中用p注入-->
<bean id="user" class="com.xiaofeng.pojo.User"p:name="段晓风"p:address-ref="address"></bean>
<bean id="address" class="com.xiaofeng.pojo.Address" p:address="小法"></bean>

xmlns:c="http://www.springframework.org/schema/c"<!--初始写法-->
<constructor-arg name="address" ref="address">
</constructor-arg>
<constructor-arg name="name" value="之秋">
</constructor-arg><!--同上原理--><bean id="user2" class="com.xiaofeng.pojo.User"c:name="之秋"c:address-ref="address"></bean>

4. 自动装配

4.1 byName自动装配

 <bean id="dog" class="com.xiaofeng.pojo.Dog"></bean><bean id="cat" class="com.xiaofeng.pojo.Cat"></bean><!--自动装配 byName通过get方法后面的名字与xml匹配寻找  区分大小写 首字母小写--><bean id="person" class="com.xiaofeng.pojo.Person" autowire="byName"></bean>

小结:需要确保bean id 的唯一值

4.2 byType自动装配

 <bean id="dog" class="com.xiaofeng.pojo.Dog"></bean><bean id="cat" class="com.xiaofeng.pojo.Cat"></bean><!--自动装配 byType通过类型与xml匹配寻找--><bean id="person2" class="com.xiaofeng.pojo.Person" autowire="byType"></bean>

小结:需要确保type的唯一

4.3 使用注解自动装配

4.3.1 配置环境

导入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:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><context:annotation-config/></beans>

4.3.2 使用@Autowired标记ref属性自动装配

  @Autowiredprivate Cat cat;@Autowiredprivate Dog dog;

注意:需要装配的对象需要在容器中都已注册

<bean id="dog" class="com.xiaofeng.pojo.Dog"></bean><bean id="cat1" class="com.xiaofeng.pojo.Cat"></bean><bean id="cat2" class="com.xiaofeng.pojo.Cat"></bean><bean id="person" class="com.xiaofeng.pojo.Person" ></bean>

 @Autowired@Qualifier("cat1")private Cat cat;
//此注解通过byType自动装配,如果存在相同Type 则通过byName  如果byName也查找不到  则可使用 @Qualifier指定name

 @Autowired@Nullableprivate Cat cat;
//使用Nullable 标记属性可以为空

4.3.2.1 小结:

@Autowired 此注解通过byType自动装配,如果存在相同Type 则通过byName

@Qualifier("") 如果byName也查找不到 则可使用 @Qualifier指定name

@Nullable 使用Nullable 标记属性可以为空

@Resource 和@Autowired差不多,但可直接传入参数选则填充对象,不用借助@Qualifier 优先通过名字然后是类型 jdk特有的注解

5. 使用注解开发

1. 导入AOP包

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"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><context:component-scan base-package="com.xiaofeng"></context:component-scan><context:annotation-config/></beans>

1. 使用@Component直接注册bean 等价于 <bean id="" class=""></bean> id默认小写

   @Component
   public class Person {//vale可以指定直接值,ref值用@Autowired自动装配@Value("段晓风")private String name;
   }

2. 注解衍生

   @value("") 指定属性直接值

   @Component 使用此注解相当于在xml中注册bean <bean id="" class=""></bean>

   @Component的衍生注解,按照MVC三层架构分层,将其注入到Spring中:

   ` Dao @Service

   `Service @Repository

   `Controller @Controller

3. 自动装配注解

   @Autowired 此注解通过byType自动装配,如果存在相同Type 则通过byName

   @Qualifier("") 如果byName也查找不到 则可使用 @Qualifier指定name

   @Nullable 使用Nullable 标记属性可以为空

   @Resource 和@Autowired差不多,但可直接传入参数选则填充对象,不用借助@Qualifier 优先通过名字然后是类型 jdk特有的注解

4. @Scope注解作用域

   @Scope("prototype")
   public class Person {@Value("段晓风")private String name;
   }

小结:

xml用于象管理

注解只负责注入属性

使用注解,一定要开启注解支持

 <context:component-scan base-package="com.xiaofeng"></context:component-scan><context:annotation-config/>

复杂对象管理 建议还是使用xml

6. 使用纯代码配置Spring注解

6.1开头总节

@Configuation等价于<Beans></Beans>

@Bean等价于<Bean></Bean>

@ComponentScan等价于<context:component-scan base-package="com.dxz.demo"/>

5.2 @Configuation+@Bean方式注入

@Configurationpublic class Config {@Beanpublic User getUser(){return new User();}

5.3 @ComponentScan(basePackages = "")+@Component

@Component
public class User {public User(){System.out.println("实例被创建了");}@Value("段晓风")private String name;}@ComponentScan(basePackages = "com.xiaofeng.pojo")
public class Config {}

5.4 @Import(Config2.class)导入其他配置类

5.5 在@configuration中引入spring的xml配置文件

@ImportResource("classpath:applicationContext-configuration.xml")

7. 动态代理

7.1 InvocationHandler

调用处理器

只有一个invoke方法,生成的代理类实例实际是调用了这个方法

7.2 Proxy

代理类

7.3 实现步骤

1.实现InvocationHandler接口

public class InvocationHandlerImpl implements InvocationHandler 

2.获取代理类实例

 public Object getProxy(){return Proxy.newProxyInstance(this.getClass().getClassLoader(),demo.getClass().getInterfaces(),this);}

通过传入实际代理对象的加载器 接口列表 调用处理器实例 来创建代理类实例

3.测试

public class Test {public static void main(String[] args) {Host host = new Host();InvocationHandlerImpl handler = new InvocationHandlerImpl(host);Rent proxy = (Rent)handler.getProxy();String rent = proxy.rent();System.out.println(rent);}
}

完整代码

package com.xiaofeng.Demo1;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class InvocationHandlerImpl implements InvocationHandler {private Object demo;public InvocationHandlerImpl(Object demo){this.demo=demo;}public Object getProxy(){return Proxy.newProxyInstance(this.getClass().getClassLoader(),demo.getClass().getInterfaces(),this);}//这里是实际调用方法,当生成的proxy调用方法时,会通过反射调用该方法,method调用的代理对象的方法,args时参数列表public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object result = method.invoke(demo, args);String result1="实际调用了这里的方法";System.out.println(result1);return result;}
}

为什么会自动调用InvocationHandlerImpl的invoke方法？ 因为JDK生成的最终真正的代理类，它继承自Proxy并实现了我们定义的Rent接口， 在实现Rent接口方法的内部，通过反射调用了InvocationHandlerImpl的invoke方法。

通过分析代码可以看出Java 动态代理，具体有如下四步骤：

通过实现 InvocationHandler 接口创建自己的调用处理器； 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类； 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型； 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

8. Spring-AOP

8.1 概念

面向切面编程

切面(aspect):日志,事物等需要插入的程序

切入点(pointcut):要插入的service类的位置(某个方法前或后)

通知(advice):切面中的方法

目标(target):被切入的对象

代理(proxy):被切入对象的代理类 (切入切面而创建的代理类,实际切入对象)

8.2 方式一:使用Spring原生API实现AOP

1. 切面实现MethodBeforeAdvice AfterReturningAdvice等方法

   public class BeforeLog implements MethodBeforeAdvice {public void before(Method method, Object[] args, Object target) throws Throwable {System.out.println("这里执行的是"+method.getName()+",他的参数是"+args+",被切入的对象是"+target.getClass().getName());}
   }

2.xml中配置切入点 切入动作等

   <bean id="beforeLog" class="com.xiaofeng.log.BeforeLog"></bean><bean id="afterLog" class="com.xiaofeng.log.AfterLog"></bean><bean id="demo" class="com.xiaofeng.serviceImpl.DemoImpl"></bean>
<aop:config><aop:pointcut id="pointcut" expression="target(com.xiaofeng.serviceImpl.DemoImpl)"/><aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"></aop:advisor><aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"></aop:advisor>
</aop:config>

3.测试

public class Test {@org.junit.Testpublic void test(){ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");Demo demo = context.getBean("demoImpl", Demo.class);demo.insert();}
}

实际上就是Spring使用动态代理创建代理类,在调用处理器中的invoke里通过反射调用代理类的方法时,在其前后插入事物

8.3 方法二:使用自定义切面实现AOP

1.创建自定义切面

public class Log {public void before(){System.out.println("这是自定义的方法前切面");}public void after(){System.out.println("这是自定义的方法后切面");}
}

2.在xml中注册切面

<bean id="demo" class="com.xiaofeng.serviceImpl.DemoImpl"></bean><bean id="diy" class="com.xiaofeng.log.Log"></bean><aop:config><aop:aspect ref="diy"><aop:pointcut id="pointcut" expression="target(com.xiaofeng.serviceImpl.DemoImpl)"/><aop:after method="after" pointcut-ref="pointcut"></aop:after><aop:before method="before" pointcut-ref="pointcut"></aop:before></aop:aspect></aop:config>

3.测试

8.4 方法三:使用纯注解实现AOP

1.创建自定义切面,并使用注解注入Spring容器

@Component
@Aspect
public class Log {@Before("execution(* com.xiaofeng.serviceImpl.DemoImpl.*(..))")public void before(){System.out.println("这是自定义的方法前切面");}@After("target(com.xiaofeng.serviceImpl.DemoImpl)")public void after(){System.out.println("这是自定义的方法后切面");}
}

这里涉及component用法:使用xml开启事物的compoent方式 代理类也通过这种方式注入

1. 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:aop="http://www.springframework.org/schema/aop"xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttps://www.springframework.org/schema/aop/spring-aop.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsd"><!--方法三:使用纯注解实现AOP--><context:component-scan base-package="com.xiaofeng"></context:component-scan><context:annotation-config/><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>

9. Spring-mybatis

核心思想:

把mybatis的配置文件,sqlSessionFactory,sqlSession对象化 全部注入包装到Spring中 由Spring代理创建实例 将mybatis代码完全封装在Spring容器中,增加复用性,方便管理

步骤:

9.1 导包

 <dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.10</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.26</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.11</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.7</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.6</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.10</version></dependency><build><resources><resource><directory>src/main/java</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource><resource><directory>src/main/resources</directory><includes><include>**/*.properties</include><include>**/*.xml</include></includes><filtering>false</filtering></resource></resources></build>

9.2 配置mybatis在Spring的基础配置

9.2.1 注入datasource Bean org.springframework.jdbc.datasource.DriverManagerDataSource

   <!--这里是把xml里的数据源包装成类-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="url" value="jdbc:mysql://localhost:3306/mybatis?				    useSSL=false&amp;serverTimezone=UTC&amp;useUnicode=true&amp;characterEncoding=UTF-8"></property><property name="username" value="root"></property><property name="password" value="Aa2289984477!"></property><property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property></bean>

9.2.2 注入SqlSessionFactory org.mybatis.spring.SqlSessionFactoryBean

<!--这里是把SqlSessionFactory包装到SqlSessionFactoryBean中,SqlSessionFactory datasource作为属性注入  在类内部进行mybatis的整合--><bean id="SqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="datasource"></property><!--这里是注册mapper.xml--><property name="mapperLocations" value="classpath:com/xiaofeng/dao/*.xml"></property><!--这里引入配置文件,可忽略--><property name="configLocation" value="classpath:mybatis.xml"></property></bean>

9.2.3 注入sqlSession org.mybatis.spring.SqlSessionTemplate

<!--同样是包装sqlSession SqlSessionFactory到SqlSessionTemplate中--><bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"><constructor-arg ref="SqlSessionFactory"/></bean>

9.3 构造Dao动作等

1.创建数据库映射对象

User

2.创建Mapper接口

public interface UserMapper {public List<User> query();
}

3.在mybatis配置中写sql

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 关联Dao接口-->
<mapper namespace="com.xiaofeng.dao.UserMapper">
<select id="query" resultType="User">select * from mybatis.user;
</select></mapper>

4.创建mapper实例(把sqlSessionTemplate作为属性传入,通过sqlSessionTemplate获取mapper,实际就是包装了mybatis的getMapper过程)

public class UserMapperImpl implements UserMapper{private SqlSessionTemplate sqlSessionTemplate;public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {this.sqlSessionTemplate = sqlSessionTemplate;}public List<User> query() {UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);return mapper.query();}
}

5.注入mapper到Spring

<bean id="UserMapper" class="com.xiaofeng.dao.UserMapperImpl"><property name="sqlSessionTemplate" ref="sqlSession"></property></bean>

6.测试

public class Test {@org.junit.Testpublic void test() {ApplicationContext context = new ClassPathXmlApplicationContext("Bean.xml");UserMapper userMapper = context.getBean("UserMapper", UserMapper.class);List<User> list = userMapper.query();for (User user:list) {System.out.println(user);}}
}

10. 事务(Spring事务管理)

事务的几大原则: 自行百度

<!--配置声明式事务--><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><constructor-arg ref="datasource" /></bean><!-- 结合AOP配置事务的织入--><!--配置事务的通知--><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="insert" propagation="REQUIRED"/><tx:method name="*" propagation="REQUIRED"></tx:method></tx:attributes></tx:advice><aop:config><aop:pointcut id="txPointCut" expression="execution(* com.xiaofeng.mapper.*.*(..))"/><aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"></aop:advisor></aop:config>