标签：gic 配置管理 ops framework cat 相关 CMF 邮件 webp
Spring : 春天 --->给软件行业带来了春天
2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。
2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术
官网 : http://spring.io/
官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/
GitHub : https://github.com/spring-projects
总结：spring就是一个轻量级的控制反转和面向切面编程的框架
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式 .
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
新建一个空白的maven项目，使用这个项目来说明IOC原理
先按照原来的方式写一段代码
1、先写一个UserDao接口
public interface UserDao {
public void getUser();
}
2、再去写Dao的实现类
public class UserDaoImpl implements UserDao {
@Override
public void getUser() {
System.out.println("获取用户数据");
}
}
3、然后去写UserService的接口
public interface UserService {
public void getUser();
}
4、最后写Service的实现类
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
5、测试一下
@Test
public void test(){
UserService service = new UserServiceImpl();
service.getUser();
}
这是我们原来的方式 , 开始大家也都是这么去写的对吧 . 那我们现在修改一下 .
把Userdao的实现类增加一个 .
public class UserDaoMySqlImpl implements UserDao {
@Override
public void getUser() {
System.out.println("MySql获取用户数据");
}
}
紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoMySqlImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
在假设, 我们再增加一个Userdao的实现类 .
public class UserDaoOracleImpl implements UserDao {
@Override
public void getUser() {
System.out.println("Oracle获取用户数据");
}
}
那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一发而动全身 .
那我们如何去解决呢 ?
我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下 .
public class UserServiceImpl implements UserService {
private UserDao userDao;
// 利用set实现
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void getUser() {
userDao.getUser();
}
}
现在去我们的测试类里 , 进行测试 ;
@Test
public void test(){
UserServiceImpl service = new UserServiceImpl();
service.setUserDao( new UserDaoMySqlImpl() );
service.getUser();
//那我们现在又想用Oracle去实现呢
service.setUserDao( new UserDaoOracleImpl() );
service.getUser();
}
大家发现了区别没有 ? 以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 .
这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !
NOTE:
控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方 ，反转的意思就是对象的创建主动权反转了。
IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。
Your application classes are combined with configuration metadata so that, after the ApplicationContext is created and initialized, you have a fully configured and executable system or application.
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。
代码测试
hello.java
public class Hello {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str=‘" + str + ‘\‘‘ +
‘}‘;
}
}
beans.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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="hello" class="Hello">
<property name="str" value="spring"/>
</bean>
</beans>
The id attribute is a string that identifies the individual bean definition.
The class attribute defines the type of the bean and uses the fully qualified classname.
测试代码
@Test
public void helloTest(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
Hello hello = (Hello) applicationContext.getBean("hello");
System.out.println(hello.toString());
}
思考
这个过程就叫控制反转 :
依赖注入 : 就是利用set方法来进行注入的.
IOC是一种编程思想，由主动的编程变成被动的接收
默认通过无参构造创建对象
创建对象的时间：在拿到容器的时候所有.xml文件中配置的对象就创建完成了，且通过同一个id创建的对象是一样的
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
通过有参构造的方式创造对象的三种方式
通过参数索引
<bean class="User" id="user">
<constructor-arg index="0" value="spring"/>
</bean>
通过参数类型{不推荐}
<bean class="User" id="user">
<constructor-arg type="java.lang.String" value="spring"/>
</bean>
通过参数的名称{推荐}
<bean class="User" id="user">
<constructor-arg name="name" value="spring"/>
</bean>
alias : 为bean设置别名 ，id可以传入userNew取对象
<alias name="userT" alias="userNew"/>
<!--bean就是java对象,由Spring创建和管理-->
<!--
id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
如果配置id,又配置了name,那么name是别名
name可以设置多个别名,可以用逗号,分号,空格隔开
如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
<property name="name" value="Spring"/>
</bean>
团队的合作通过import来实现 .
<import resource="{path}/beans.xml"/>
<import resource="{path}/beans1.xml"/>
<import resource="{path}/beans2.xml"/>
依赖注入（DI: dependency injection）：
<bean class="User" id="user">
<constructor-arg name="name" value="spring"/>
</bean>
要求被注入的属性 , 必须有set方法
环境搭建
pojo类
@Data
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbies;
private Map<String, String> card;
private Set<String> games;
private String wife;
private Properties info;
}
@Data
public class Address {
private String address;
}
beans.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">
<bean id="stu" class="com.iandf.pojo.Student">
<!--value注入-->
<property name="name" value="黄鹤"/>
<!--bean注入-->
<property name="address" ref="address"/>
<!--数组-->
<property name="books">
<array>
<value>红楼梦</value>
<value>水浒传</value>
<value>三国演义</value>
</array>
</property>
<!--list-->
<property name="hobbies">
<list>
<value>敲代码</value>
<value>看电影</value>
</list>
</property>
<!--map-->
<property name="card">
<map>
<entry key="学号" value="123456"/>
</map>
</property>
<!--set-->
<property name="games">
<set>
<value>lol</value>
<value>王者</value>
</set>
</property>
<!--null-->
<property name="wife">
<null/>
</property>
<!--properties-->
<property name="info">
<props>
<prop key="银行卡">123414564</prop>
</props>
</property>
</bean>
<bean id="address" class="com.iandf.pojo.Address">
<property name="address" value="湖南"/>
</bean>
</beans>
测试类
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student stu = (Student) context.getBean("stu");
System.out.println(stu.toString());
结果
/*Student(name=黄鹤
, address=Address(address=湖南)
, books=[红楼梦, 水浒传, 三国演义]
, hobbies=[敲代码, 看电影]
, card={学号=123456}
, games=[lol, 王者]
, wife=null
, info={银行卡=123414564})*/
Spring supports extensible configuration formats with namespaces, which are based on an XML Schema definition
xml shortcut with the p-namespace 相当于property标签
导入命名空间
xmlns:p="http://www.springframework.org/schema/p"
使用
<bean id="user" class="com.iandf.pojo.User" p:id="123" p:name="黄鹤"/>
xml shortcut with c-namespace 相当于constructor-arg标签
导入命名空间
xmlns:c="http://www.springframework.org/schema/c"
使用
<bean id="user2" class="com.iandf.pojo.User" c:id="456" c:name="利诱">
单例模式（默认的）：spring容器为每一个bean分配一个对象
原型模式：每一次从spring容器中获取到的对象都是新的
<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>
request、session、...都是在web应用中使用的
自动装配说明
Spring中bean有三种装配机制，分别是：
这里我们主要讲第三种：自动化的装配bean。
Spring的自动装配需要从两个角度来实现，或者说是两个操作：
组件扫描和自动装配组合发挥巨大威力，使得显示的配置降低到最少。
推荐不使用自动装配xml配置 , 而使用注解 .
测试环境搭建
1、新建一个项目
2、新建两个实体类，Cat Dog 都有一个叫的方法
public class Cat {
public void shout() {
System.out.println("miao~");
}
}
public class Dog {
public void shout() {
System.out.println("wang~");
}
}
3、新建一个用户类 User
public class User {
private Cat cat;
private Dog dog;
private String str;
}
4、编写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="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="user" class="com.kuang.pojo.User">
<property name="cat" ref="cat"/>
<property name="dog" ref="dog"/>
<property name="str" value="qinjiang"/>
</bean>
</beans>
5、测试
public class MyTest {
@Test
public void testMethodAutowire() {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.getCat().shout();
user.getDog().shout();
}
}
结果正常输出，环境OK
byName
autowire byName (按名称自动装配)
由于在手动配置xml过程中，常常发生字母缺漏和大小写等错误，而无法对其进行检查，使得开发效率降低。
采用自动装配将避免这些错误，并且使配置简单化。
测试：
1、修改bean配置，增加一个属性 autowire="byName"
<bean id="user" class="com.kuang.pojo.User" autowire="byName">
<property name="str" value="qinjiang"/>
</bean>
2、再次测试，结果依旧成功输出！
3、我们将 cat 的bean id修改为 catXXX
4、再次测试， 执行时报空指针java.lang.NullPointerException。因为按byName规则找不对应set方法，真正的setCat就没执行，对象就没有初始化，所以调用时就会报空指针错误。
小结：
当一个bean节点带有 autowire byName的属性时。
将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。
去spring容器中寻找是否有此字符串名称id的对象。
如果有，就取出注入；如果没有，就报空指针异常。
byType
autowire byType (按类型自动装配)
使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一的异常。
NoUniqueBeanDefinitionException
测试：
1、将user的bean配置修改一下 ： autowire="byType"
2、测试，正常输出
3、在注册一个cat 的bean对象！
<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>
<bean id="user" class="com.kuang.pojo.User" autowire="byType">
<property name="str" value="qinjiang"/>
</bean>
4、测试，报错：NoUniqueBeanDefinitionException
5、删掉cat2，将cat的bean名称改掉！测试！因为是按类型装配，所以并不会报异常，也不影响最后的结果。甚至将id属性去掉，也不影响结果。
这就是按照类型自动装配！
<?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/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:annotation-config/>
</beans>
@autowired默认是byType，byType找不到再使用byName
如果出现多个bean且byName找不到的情况下可以使用@Qualifier("xxx") xxx为bean的id
@Autowired
@Qualifier("cat1")
private Cat cat;
@Autowired
@Qualifier("dog1")
private Dog dog;
<bean id="dog2" class="Dog"/>
<bean id="dog1" class="Dog"/>
<bean id="cat1" class="Cat"/>
<bean id="cat2" class="Cat"/>
<bean id="person" class="Person">
<property name="name" value="huang"/>
</bean>
@Resource默认是byName,byType找不到再byType
byName和byType都找不到的情况下使用 @Resource(name = "xxx") xxx为bean的id
@Resource(name = "cat1")
private Cat cat;
@Resource
private Dog dog;
<bean id="dog" class="Dog"/>
<bean id="cat1" class="Cat"/>
<bean id="cat2" class="Cat"/>
<bean id="person" class="Person">
<property name="name" value="huang"/>
</bean>
@Autowired与@Resource异同：
1、@Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。
2、@Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用
3、@Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。
它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。
我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！
配置环境
在配置文件当中，还得要引入一个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/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:annotation-config/>
<context:component-scan base-package="com.iandf.pojo"/>
</beans>
@Component(value = "user")//默认就是user
public class User {
@Value("iandf")//优先使用
private String name = "aaa";
}
@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
@Value("iandf")
// 相当于配置文件中 <property name="name" value="iandf"/>,也可以写在set方法上
为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。
写上这些注解，就相当于将这个类交给Spring管理装配了！
@scope
@Component(value = "user")
@Scope("prototype")
public class User {
@Value("iandf")//优先使用
private String name = "aaa";
}
XML与注解比较
xml与注解整合开发 ：推荐最佳实践
<context:annotation-config/>
作用：
进行注解驱动注册，从而使注解生效
用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
如果不扫描包，就需要手动配置bean
如果不加注解驱动，则注入的值为null
JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能 。
测试
编写config类
@Configuration//代表这是一个配置类,相当于beans.xml，同时将BeansConfig交给spring管理
public class BeansConfig {
@Bean//id是方法名，class是返回值类型
public User getUser(){
return new User();
}
}
编写一个实体类,使用component标注
@Component
public class User {
private String name = "iandf";
}
测试 使用纯注解方式需要通过AnnotationConfigApplicationContext类拿到容器
@Test
public void javaConfigTest(){
ApplicationContext context = new AnnotationConfigApplicationContext("com.iandf.config");
BeansConfig beansConfig = context.getBean("beansConfig", BeansConfig.class);
User user = beansConfig.getUser();
System.out.println(user.toString());
}
@Test
public void javaConfigTest2() {
ApplicationContext context = new AnnotationConfigApplicationContext("com.iandf.config");
User user = context.getBean("getUser", User.class);
System.out.println(user.toString());
}
也可以使用@Import(XxxConfig.class) 导入其他配置类相当于inculde 标签
关于这种Java类的配置方式，我们在之后的SpringBoot 和 SpringCloud中还会大量看到，我们需要知道这些注解的作用即可！
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
提供声明式事务；允许用户自定义切面
以下名词需要了解下：
SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice:
即 Aop 在 不改变原有代码的情况下 , 去增加新的功能 .
需求：使UserServiceImpl 在不改变源码的情况下，使它原本的增删改查实现前置日志和后置日志的功能
搭建环境
public interface IUserService {
void add();
void delete();
void update();
void select();
}
public class UserServiceImpl implements IUserService{
public void add() {
System.out.println("添加一个用户");
}
public void delete() {
System.out.println("删除一个用户");
}
public void update() {
System.out.println("修改一个用户");
}
public void select() {
System.out.println("查询一个用户");
}
}
Log类
public class BeforeLog implements MethodBeforeAdvice {
public void before(Method method, Object[] args, Object target) {
System.out.println((target != null ? target.getClass().getName() : null) +"执行了"+method.getName()+"方法");
}
}
public class AfterLog implements AfterReturningAdvice {
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println((target != null ? target.getClass().getName() : null) +"执行完了"+method.getName()+"返回值为: "+returnValue);
}
}
配置文件
<?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="userService" class="com.iandf.service.UserServiceImpl"/>
<bean id="afterLog" class="com.iandf.log.AfterLog"/>
<bean id="beforeLog" class="com.iandf.log.BeforeLog"/>
<aop:config>
<!--切入点 expression:表达式匹配要执行的方法-->
<aop:pointcut id="pointcut" expression="execution(* com.iandf.service.UserServiceImpl.*(..))"/>
<!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
<aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
定义切点：
expression="execution(* com.iandf.service.UserServiceImpl.*(..))
对这个表达式分析：
测试代码
@Test
public void LogTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//获取代理对象，注意代理对象是其接口的实现类
IUserService userService = context.getBean("userService", IUserService.class);
userService.add();
}
测试结果
Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专注领域业务 , 其本质还是动态代理 .
步骤：
log类
public class LogAopDiy {
public void before(){
System.out.println("方法执行前");
}
public void after(){
System.out.println("方法执行后");
}
}
配置文件
<bean id="diy" class="com.iandf.diy.LogAopDiy"/>
<aop:config>
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id="pointcut" expression="execution(* com.iandf.service.UserServiceImpl.*(..))"/>
<!--通知：要执行的方法-->
<aop:after method="after" pointcut-ref="pointcut"/>
<aop:before method="before" pointcut-ref="pointcut"/>
</aop:aspect>
</aop:config>
测试结果
步骤：
AnnotationAop
@Aspect//把该类定义成一个切面
public class AnnotationAop {
@Before(value = "execution(* com.iandf.service.UserServiceImpl.*(..))")//配置切入点
public void before(){
System.out.println("方法执行前");
}
@After(value = "execution(* com.iandf.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("方法执行后");
}
@AfterReturning(value = "execution(* com.iandf.service.UserServiceImpl.*(..))")
public void afterReturning(){
System.out.println("方法返回结果");
}
@Around(value = "execution(* com.iandf.service.UserServiceImpl.*(..))")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
//ProceedingJoinPoint joinPoint与切入点匹配的执行点。
System.out.println("方法环绕前");
Object proceed = joinPoint.proceed();//执行目标对象调用的方法
System.out.println("方法环绕后");
return proceed;
}
}
配置文件
<bean id="annotationAop" class="com.iandf.annotation_aop.AnnotationAop"/>
<!--支持注解-->
<aop:aspectj-autoproxy proxy-target-class="false"/>
aop:aspectj-autoproxy：说明
通过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean创建代理，织入切面。当然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了
<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。
步骤：
代码案例
User、UserMapper 和 UserMapper.xml
@Data
public class User {
private int id;
private String name;
private String password;
}
public interface UserMapper {
List<User> getUserList();
}
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.iandf.dao.UserMapper">
<select id="getUserList" resultType="user">
select * from mybatis.user
</select>
</mapper>
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<package name="com.iandf.pojo"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper class="com.iandf.dao.UserMapper"/>
</mappers>
</configuration>
测试方法
@Test
public void getUserListTest(){
String resource = "mybatis-config.xml";
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
try {
SqlSessionFactory build = sqlSessionFactoryBuilder.build(Resources.getResourceAsStream(resource));
SqlSession sqlSession = build.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = userMapper.getUserList();
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
} catch (IOException e) {
e.printStackTrace();
}
}
junit
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
mybatis
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
mysql-connector-java
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
spring相关
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.10.RELEASE</version>
</dependency>
aspectJ AOP 织入器
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
mybatis-spring整合包 【重点】
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.2</version>
</dependency>
配置Maven静态资源过滤问题！
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。
SqlSessionFactory还需要一个数据源，所指定的映射器类必须是一个接口，而不是具体的实现类。
在 MyBatis 中，你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后，你可以使用它来执行映射了的语句，提交或回滚连接，最后，当不再需要它的时候，你可以关闭 session。使用 MyBatis-Spring 之后，你不再需要直接使用 SqlSessionFactory 了，因为你的 bean 可以被注入一个线程安全的 SqlSession，它能基于 Spring 的事务配置来自动提交、回滚、关闭 session。
编写实体类User
在spring-dao.xml配置文件中配置数据源 这里使用的数据源是spring-jdbc依赖下的DriverManagerDataSource。也可以使用dbcp c3po druid
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306?mybatis/useSSL=true&useUnicode=true&characterEncoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</bean>
编写UserMapper和UserMapper.xml 和原生开发一样
在spring-dao.xml配置文件中创建SqlSessionFactory
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--关联Mybatis配置文件-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<!--关联mapper文件-->
<property name="mapperLocations" value="classpath:com/iandf/dao/*.xml"/>
</bean>
在spring-dao.xml配置文件中创建SqlSessionTemplate
<bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
<!--没有set方法，所以只能是构造器注入-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
编写UserMapper实现类
public class UserMapperImpl implements UserMapper {
private SqlSessionTemplate sqlSessionTemplate;
public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
this.sqlSessionTemplate = sqlSessionTemplate;
}
public List<User> getUserList() {
UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
return mapper.getUserList();
}
}
将刚刚写好的spring-dao.xml和UserMapper实现类整合到项目的配置文件中
<?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">
<import resource="spring-dao.xml"/>
<bean id="userDao" class="com.iandf.dao.UserMapperImpl">
<property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
</bean>
</beans>
编写测试方
@Test
public void springMybatisTest(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapperImpl userDao = context.getBean("userDao", UserMapperImpl.class);
for (User user : userDao.getUserList()) {
System.out.println(user);
}
}
步骤：
编写实体类User
在spring-dao.xml配置文件中配置数据源
编写UserMapper和UserMapper.xml 和原生开发一样
在spring-dao.xml配置文件中创建SqlSessionFactory
编写UserMapper实现类并继承SqlSessionDaoSupport 不用编写SqlSessionTemplate
public class UserMapperImplBySqlSessionDaoSupport extends SqlSessionDaoSupport implements UserMapper {
public List<User> getUserList() {
//getSqlSession()返回的是SqlSessionTemplate，只是SqlSessionTemplate实现了SqlSession接口
return getSqlSession().getMapper(UserMapper.class).getUserList();
}
}
在applicationContext.xml中注册UserMapperImplBySqlSessionDaoSupport的bean
<bean id="userDao2" class="com.iandf.dao.UserMapperImplBySqlSessionDaoSupport">
<property name="sqlSessionTemplate" ref="sqlSessionTemplate"/>
</bean>
测试方法
@Test
public void springMybatisTest2(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
SqlSessionTemplate sqlSessionTemplate = context.getBean("sqlSessionTemplate", SqlSessionTemplate.class);
UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
for (User user : mapper.getUserList()) {
System.out.println(user);
}
}
事务管理分类：
配置生命式事务
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
配置事务通知 需要配置tx命名空间
<!--配置事务通知-->
<tx:advice id="tx_advice" transaction-manager="transactionManager">
<tx:attributes>
<!--*：该通知在任意方法上生效，也可以是get*: 以get开头的所有方法生效-->
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
配置切入点
<!--配置接入点-->
<aop:config>
<aop:pointcut id="tx_pointcut" expression="execution(* com.iandf.dao.UserMapper.*(..))"/>
<aop:advisor advice-ref="tx_advice" pointcut-ref="tx_pointcut"/>
</aop:config>
上面三步做完之后就成功的把事务织入到原来的代码中了
标签：gic 配置管理 ops framework cat 相关 CMF 邮件 webp
原文地址：https://www.cnblogs.com/iandf/p/13597881.html
