基础总结"/>
spring基础总结
第一章 spring
Spring Ioc
程序耦合
（1） 内容耦合。当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
（2） 公共耦合。两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
（3） 外部耦合 。一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
（4） 控制耦合 。一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。
（5） 标记耦合 。若一个模块A通过接口向两个模块B和C传递一个公共参数，那么称模块B和C之间存在一个标记耦合。
（6） 数据耦合。模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。
（7） 非直接耦合 。两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。
内聚与耦合
内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却 要不那么紧密。
内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。
工厂模式解耦
在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。 那么，这个读取配置文件，创建和获取三层对象的类就是工厂。
控制反转-Inversion Of Control
1、存哪去？
分析：由于我们是很多对象，肯定要找个集合来存。这时候有Map和List供选择。
到底选Map还是List就看我们有没有查找需求。有查找需求，选Map。
所以我们的答案就是 在应用加载时，创建一个Map，用于存放三层对象。
我们把这个map称之为容器。
2、还是没解释什么是工厂？
工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。
原来： 我们在获取对象时，都是采用new的方式。是主动的。
现在： 我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。
使用spring的 ioc解决程序耦合
创建业务层和实现类
/**
* 账户的业务层接口
* @author 黑马程序员
* @Company
* @Version 1.0
*/
public interface IAccountService {/** * 保存账户（此处只是模拟，并不是真的要保存） */ void saveAccount();
}
/**
* 账户的业务层实现类
* @author 黑马程序员
* @Company * @Version 1.0
*/
public class AccountServiceImpl implements IAccountService { private IAccountDao accountDao = new AccountDaoImpl();//此处的依赖关系有待解决@Override public void saveAccount(){ accountDao.saveAccount(); }
}
3.1.3 创建持久层接口和实现类 /** * 账户的持久层接口* @author 黑马程序员 * @Company * @Version 1.0 */public interface IAccountDao { /** * 保存账户 */ void saveAccount(); } /** * 账户的持久层实现类* @author 黑马程序员* @Company * @Version 1.0 */ public class AccountDaoImpl implements IAccountDao{@Override public void saveAccount() { System.out.println("保存了账户"); } }
基于xml的配置
第一步 给配置文件导入约束
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="" xmlns:xsi="" xsi:schemaLocation=" .xsd">
</beans>
第二步 让spring管理资源 ，给配置文件配置service和dao
<!-- bean标签：用于配置让spring创建对象，并且存入ioc容器之中 id属性：对象的唯一标识。 class属性：指定要创建对象的全限定类名 -->
<!-- 配置service -->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"</bean> <!-- 配置dao -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"></bean>
ioc 中bean标签和管理对象细节
bean标签
作用：
用于配置对象让spring来创建的。 默认情况下它调用的是类中的无参构造函数。
如果没有无参构造函数则不能创建成功。
属性：
id：给对象在容器中提供一个唯一标。用于获取对象。
class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
scope：指定对象的作用范围。
- singleton :默认值，单例的.
- prototype :多例的
- request : WEB项目中,Spring创建一个Bean的对象,将对象存入到request域中.
- session : WEB项目中,Spring创建一个Bean的对象,将对象存入到session域中.
- global session : WEB项目中,应用在Portlet环境.如果没有Portlet环境那么globalSession相当于session.
init-method：指定类中的初始化方法名称。 destroy-method：指定类中销毁方法名称。
destroy-method：指定类中销毁方法名称。
bean的作用范围和生命周期
单例对象：scope="singleton" 一个应用只有一个对象的实例。它的作用范围就是整个引用。 生命周期： 对象出生：当应用加载，创建容器时，对象就被创建了。 对象活着：只要容器在，对象一直活着。 对象死亡：当应用卸载，销毁容器时，对象就被销毁了。 多例对象：scope="prototype" 每次访问对象时，都会重新创建对象实例。 生命周期： 对象出生：当使用对象时，创建新的对象实例。 对象活着：只要对象在使用中，就一直活着。 对象死亡：当对象长时间不用时，被java的垃圾回收器回收了。
实例化bean的三种方式
第一种方式：使用默认无参构造函数
<!--在默认情况下： 它会根据默认无参构造函数来创建类对象。如果bean中没有默认无参构造函数，将会创建失败。-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"/>第二种方式：spring管理静态工厂-使用静态工厂的方法创建对象
/**
* 模拟一个静态工厂，创建业务层实现类
*/
public class StaticFactory { public static IAccountService createAccountService(){ return new AccountServiceImpl(); }
}
<!-- 此种方式是: 使用StaticFactory类中的静态方法createAccountService创建对象，并存入spring容器 id属性：指定bean的id，用于从容器中获取class属性：指定静态工厂的全限定类名factory-method属性：指定生产对象的静态方法 -->
<bean id="accountService" class="com.itheima.factory.StaticFactory" factory-method="createAccountService"></bean>
第三种方式：spring管理实例工厂-使用实例工厂的方法创建对象
/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {public IAccountService createAccountService(){ return new AccountServiceImpl(); }
}
<!-- 此种方式是： 先把工厂的创建交给spring来管理。 然后在使用工厂的bean来调用里面的方法
factory-bean属性：用于指定实例工厂bean的id。
factory-method属性：用于指定实例工厂中创建对象的方法。 -->
<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instancFactory" factory-method="createAccountService"></bean>
spring 依赖注入
构造函数注入
/**
*/
public class AccountServiceImpl implements IAccountService { private String name;private Integer age;private Date birthday;public AccountServiceImpl(String name, Integer age, Date birthday) { this.name = name; this.age = age; this.birthday = birthday; } @Override public void saveAccount() { System.out.println(name+","+age+","+birthday); }
}
<!-- 使用构造函数的方式，给service中的属性传值 要求： 类中需要提供一个对应参数列表的构造函数。 涉及的标签：
constructor-arg 属性：index:指定参数在构造函数参数列表的索引位置 type:指定参数在构造函数中的数据类型name:指定参数在构造函数中的名称 用这个找给谁赋值 =======上面三个都是找给谁赋值，下面两个指的是赋什么值的============== value:它能赋的值是基本数据类型和String类型 ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"> <constructor-arg name="name" value="张三"></constructor-arg> <constructor-arg name="age" value="18"></constructor-arg> <constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<bean id="now" class="java.util.Date"></bean>
set方法注入
public class AccountServiceImpl implements IAccountService { private String name; private Integer age; private Date birthday; public void setName(String name) { this.name = name; }public void setAge(Integer age) {this.age = age; }public void setBirthday(Date birthday) { this.birthday = birthday; } @Overridepublic void saveAccount() { System.out.println(name+","+age+","+birthday); }
}
<!-- 通过配置文件给bean中的属性传值：使用set方法的方式 涉及的标签： property属性: name：找的是类中set方法后面的部分ref：给属性赋值是其他bean类型的 value：给属性赋值是基本数据类型和string类型的 实际开发中，此种方式用的较多。-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"> <property name="name" value="test"></property> <property name="age" value="21"></property> <property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>
使用p名称空间注入数据
/*** 使用p名称空间注入，本质还是调用类中的set方法 */
public class AccountServiceImpl4 implements IAccountService {private String name; private Integer age;private Date birthday; public void setName(String name) {this.name = name; } public void setAge(Integer age) {this.age = age;} public void setBirthday(Date birthday) { this.birthday = birthday; }@Overridepublic void saveAccount() { System.out.println(name+","+age+","+birthday);}
}
配置文件代码：
<beans xmlns="" xmlns:p=""
xmlns:xsi="" xsi:schemaLocation=" .xsd"> <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl4" p:name="test" p:age="21" p:birthday-ref="now"/>
</beans>
注入集合属性
顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。我们这里介绍注入数组，List,Set,Map,Properties。具体代码如下： /***/ public class AccountServiceImpl implements IAccountService { private String[] myStrs; private List<String> myList; private Set<String> mySet; private Map<String,String> myMap; private Properties myProps; public void setMyStrs(String[] myStrs) { this.myStrs = myStrs; } public void setMyList(List<String> myList) { this.myList = myList; } public void setMySet(Set<String> mySet) { this.mySet = mySet; } public void setMyMap(Map<String, String> myMap) { this.myMap = myMap; } public void setMyProps(Properties myProps) { this.myProps = myProps; } @Override public void saveAccount() { System.out.println(Arrays.toString(myStrs)); System.out.println(myList); System.out.println(mySet); System.out.println(myMap);System.out.println(myProps); } }
<!-- 注入集合数据List结构的：array,list,set Map结构的 map,entry,props,prop
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"><!-- 在注入集合数据时，只要结构相同，标签可以互换 --> <!-- 给数组注入数据 --> <property name="myStrs"><set> <value>AAA</value> <value>BBB</value><value>CCC</value></set> </property><!-- 注入list集合数据 --> <property name="myList"><array> <value>AAA</value> <value>BBB</value><value>CCC</value> </array> </property> <!-- 注入set集合数据 --> <property name="mySet"> <list> <value>AAA</value> <value>BBB</value><value>CCC</value></list></property><!-- 注入Map数据 --> <property name="myMap"><props> <prop key="testA">aaa</prop> <prop key="testB">bbb</prop> </props></property><!-- 注入properties数据 --><property name="myProps"><map> <entry key="testA" value="aaa"></entry> <entry key="testB"> <value>bbb</value> </entry> </map></property>
</bean>
基于注解的IOC配置
第一步：使用@Component注解配置管理的资源
/**
* 账户的业务层实现类
*@author 黑马程序员
* @Company
* @Version 1.0
*/
@Component("accountService")
public class AccountServiceImpl implements IAccountService { private IAccountDao accountDao; public void setAccountDao(IAccountDao accountDao) { this.accountDao = accountDao; }
}
/**
* 账户的持久层实现类
* @author 黑马程序员
* @Company
* @Version 1.0
*/
@Component("accountDao")
public class AccountDaoImpl implements IAccountDao { private DBAssit dbAssit;
}
第二步 创建spring的xml配置文件并开启对注解的支持
注意：
基于注解整合时，导入约束时需要多导入一个context名称空间下的约束。
由于我们使用了注解配置，此时不能在继承JdbcDaoSupport，需要自己配置一个JdbcTemplate
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="" xmlns:context="" xmlns:xsi="" xsi:schemaLocation=" .xsd .xsd"><!-- 告知spring创建容器时要扫描的包 --> <context:component-scan base-package="com.itheima"></context:component-scan><!-- 配置dbAssit --> <bean id="dbAssit" class="com.itheima.dbassit.DBAssit"><property name="dataSource" ref="dataSource"></property> </bean> <!-- 配置数据源 --><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property> <property name="user" value="root"></property> <property name="password" value="1234"></property></bean>
</beans>
常用注解
用于创建对象的
@Component
相当于：
作用： 把资源让spring来管理。相当于在xml中配置一个bean。
属性： value：指定bean的id。如果不指定value属性，默认bean的id是当前类的类名。首字母小写。
@Controller @Service @Repository
他们三个注解都是针对一个的衍生注解，他们的作用及属性都是一模一样的。
他们只不过是提供了更加明确的语义化。
@Controller：一般用于表现层的注解。
@Service：一般用于业务层的注解。
@Repository：一般用于持久层的注解。
细节：如果注解中有且只有一个属性要赋值时，且名称是value，value在赋值是可以不写。
用于注入数据的
相当于：
@Autowired
作用： 自动按照类型注入。当使用注解注入属性时，set方法可以省略。它只能注入其他bean类型。当有多个类型匹配时，使用要注入的对象变量名称作为bean的id，在spring容器查找，找到了也可以注入成功。找不到就报错
@Qualifier
作用：在自动按照类型注入的基础之上，再按照Bean的id注入。它在给字段注入时不能独立使用，必须和@Autowire一起使用；但是给方法参数注入时，可以独立使用。
属性： value：指定bean的id。
@Resource
作用： 直接按照Bean的id注入。它也只能注入其他bean类型。
属性： name：指定bean的id。
@Value
作用： 注入基本数据类型和String类型数据的
属性： value：用于指定值
用于改变作用范围的
相当于：
@Scope
作用： 指定bean的作用范围。
属性： value：指定范围的值。取值：singleton prototype request session globalsession`
和生命周期相关的：(了解)
相当于：
@PostConstruct
作用： 用于指定初始化方法。
@PreDestroy
作用： 用于指定销毁方法。
关于Spring注解和XML的选择问题
注解的优势：
配置简单，维护方便（我们找到类，就相当于找到了对应的配置）。
XML的优势：
修改时，不用改源码。不涉及重新编译和部署。
Spring管理Bean方式的比较：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pHa8W2sg-1617605762017)(E:\A_MyCodeLearnNote\TyproNoteUnload\javaee笔记\总结.assets\image-20200731155257278.png)]
新注解
@Configuration
作用：用于指定当前类是一个spring配置类，当创建容器时会从该类上加载注解。获取容器时需要使用AnnotationApplicationContext(有@Configuration注解的类.class)。
属性： value:用于指定配置类的字节码示例代码：
/**
* spring的配置类，相当于bean.xml文件
* @Company * @Version 1.0
*/
@Configuration
public class SpringConfiguration {
}
注意： 我们已经把配置文件用类来代替了，但是如何配置创建容器时要扫描的包呢？ 请看下一个注解。
#####@ComponentScan
作用： 用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的： <context:component-scan base-package="com.itheima"/>是一样的。属性： basePackages：用于指定要扫描的包。和该注解中的value属性作用一样。 示例代码：/** * spring的配置类，相当于bean.xml文件 * @Company * @Version 1.0*/@Configuration @ComponentScan("com.itheima") public class SpringConfiguration { }
注意： 我们已经配置好了要扫描的包，但是数据源和JdbcTemplate对象如何从配置文件中移除呢？ 请看下一个注解。
@Bean
作用： 该注解只能写在方法上，表明使用此方法创建一个对象，并且放入spring容器。
属性： name：给当前@Bean注解方法创建的对象指定一个名称(即bean的id）
/**
* 连接数据库的配置类
* @Company
* @Version 1.0
*/
public class JdbcConfig { /*** 创建一个数据源，并存入spring容器中 * @return */@Bean(name="dataSource") public DataSource createDataSource() {try { ComboPooledDataSource ds = new ComboPooledDataSource(); ds.setUser("root"); ds.setPassword("1234"); ds.setDriverClass("com.mysql.jdbc.Driver"); ds.setJdbcUrl("jdbc:mysql:///spring_day02");return ds;} catch (Exception e) { throw new RuntimeException(e);} } /** * 创建一个DBAssit，并且也存入spring容器中* @param dataSource * @return */ @Bean(name="dbAssit")public DBAssit createDBAssit(DataSource dataSource) { return new DBAssit(dataSource);}
}
注意: 我们已经把数据源和DBAssit从配置文件中移除了，此时可以删除bean.xml了。但是由于没有了配置文件，创建数据源的配置又都写死在类中了。如何把它们配置出来呢？ 请看下一个注解。
@PropertySource
作用：用于加载.properties文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到properties配置文件中，就可以使用此注解指定properties配置文件的位置。 属性： value[]：用于指定properties文件位置。如果是在类路径下，需要写上classpath:
配置：/** * 连接数据库的配置类 * @Company * @Version 1.0 */ public class JdbcConfig {@Value("${jdbc.driver}") private String driver;@Value("${jdbc.url}") private String url;@Value("${jdbc.username}") private String username; @Value("${jdbc.password}") private String password; /*** 创建一个数据源，并存入spring容器中 * @return*/@Bean(name="dataSource")public DataSource createDataSource() { try { ComboPooledDataSource ds = new ComboPooledDataSource();ds.setDriverClass(driver); ds.setJdbcUrl(url); ds.setUser(username); ds.setPassword(password);return ds; } catch (Exception e) {throw new RuntimeException(e);} }}
jdbc.properties文件： jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/day44_ee247_springjdbc.username=root jdbc.password=1234 注意： 此时我们已经有了两个配置类，但是他们还没有关系。如何建立他们的关系呢？ 请看下一个注解。
@Import
作用： 用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration注解。当然，写上也没问题。 属性： value[]：用于指定其他配置类的字节码。 示例代码： @Configuration@ComponentScan(basePackages = "com.itheima.spring") @Import({ JdbcConfig.class}) public class SpringConfiguration { }@Configuration @PropertySource("classpath:jdbc.properties") public class JdbcConfig{ }
注意： 我们已经把要配置的都配置好了，但是新的问题产生了，由于没有配置文件了，如何获取容器呢？ 请看下一小节。
通过注解获取容器
ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
###Spring Aop
aop概述
什么是Aop
AOP：全称是Aspect Oriented Programming即：面向切面编程。
简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。
#####AOP的作用及优势
作用：
在程序运行期间，不修改源码对已有方法进行增强。
优势：
减少重复代码
提高开发效率
维护方便
####Aop的具体应用
客户的业务层实现类/**账户的业务层实现类
@author 黑马程序员
@Company
@Version 1.0
*/
public class AccountServiceImpl implements IAccountService {
private IAccountDao accountDao;public void setAccountDao(IAccountDao accountDao) {this.accountDao = accountDao;}@Overridepublic void saveAccount(Account account) throws SQLException { accountDao.save(account);}@Overridepublic void updateAccount(Account account) throws SQLException{ accountDao.update(account);}@Overridepublic void deleteAccount(Integer accountId) throws SQLException{ accountDao.delete(accountId);}@Overridepublic Account findAccountById(Integer accountId) throws SQLException {return accountDao.findById(accountId);}@Overridepublic List<Account> findAllAccount() throws SQLException{
return accountDao.findAll();
}}
问题就是： 事务被自动控制了。换言之，我们使用了connection对象的setAutoCommit(true) 此方式控制事务，如果我们每次都执行一条sql语句，没有问题，但是如果业务方法一次要执行多条sql语句，这种方式就无法实现功能了。
业务层接口/**转账
@param sourceName
@param targetName
@param money
*/void transfer(String sourceName,String targetName,Float money);业务层实现类：@Overridepublic void transfer(String sourceName, String targetName, Float money) {//根据名称查询两个账户信息Account source = accountDao.findByName(sourceName); Account target = accountDao.findByName(targetName);//转出账户减钱，转入账户加钱source.setMoney(source.getMoney()-money); target.setMoney(target.getMoney()+money);//更新两个账户accountDao.update(source);
int i=1/0;
//模拟转账异常
accountDao.update(target);}
解决此问题
解决办法： 让业务层来控制事务的提交和回滚。（这个我们之前已经在web阶段讲过了） 改造后的业务层实现类： 注：此处没有使用spring的IoC. /*** 账户的业务层实现类 * @Company * @Version 1.0 */public class AccountServiceImpl implements IAccountService {private IAccountDao accountDao = new AccountDaoImpl();@Overridepublic void saveAccount(Account account) {try { TransactionManager.beginTransaction(); accountDao.save(account);TransactionManagermit();} catch (Exception e) {TransactionManager.rollback();e.printStackTrace();}finally {TransactionManager.release(); }}@Overridepublic void updateAccount(Account account) {try { TransactionManager.beginTransaction(); accountDao.update(account); TransactionManagermit();} catch (Exception e) { TransactionManager.rollback(); e.printStackTrace();}finally {TransactionManager.release();}}@Overridepublic void deleteAccount(Integer accountId) {try { TransactionManager.beginTransaction(); accountDao.delete(accountId); TransactionManagermit();} catch (Exception e) { TransactionManager.rollback();e.printStackTrace();}finally {TransactionManager.release();}}public void transfer(String sourceName, String targetName, Float money) {try { TransactionManager.beginTransaction();Account source = accountDao.findByName(sourceName); Account target = accountDao.findByName(targetName);source.setMoney(source.getMoney()-money);target.setMoney(target.getMoney()+money); accountDao.update(source);int i=1/0;accountDao.update(target);TransactionManagermit();} catch (Exception e) { TransactionManager.rollback(); e.printStackTrace();}finally {TransactionManager.release();}public class TransactionManager { //定义一个DBAssit private static DBAssit dbAssit = new DBAssit(C3P0Utils.getDataSource(),true); //开启事务public static void beginTransaction() {try {dbAssit.getCurrentConnection().setAutoCommit(false); } catch (SQLException e) {e.printStackTrace(); }} //提交事务 public static void commit() { try {dbAssit.getCurrentConnection()mit(); } catch (SQLException e) { e.printStackTrace();}}//回滚事务public static void rollback() { try { dbAssit.getCurrentConnection().rollback(); } catch (SQLException e) { e.printStackTrace(); } }//释放资源 public static void release() { try { dbAssit.releaseConnection(); } catch (Exception e) {e.printStackTrace(); } }
动态代理常用的有两种方式
基于接口的动态代理
提供者：JDK 官方的 Proxy 类。
要求：被代理类最少实现一个接口。
基于子类的动态代理
提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
要求：被代理类不能用 final 修饰的类（最终类）。
使用 JDK 官方的 Proxy 类创建代理对象
此处我们使用的是一个演员的例子：
在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。
而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪
人来找了。下面我们就用代码演示出来。
/**
* 一个经纪公司的要求:
* 能做基本的表演和危险的表演
*/
public interface IActor {
/**
* 基本演出
* @param money
*/
public void basicAct(float money);
/**
* 危险演出
* @param money
*/
public void dangerAct(float money);
}
/**
* 一个演员
*/
//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
public class Actor implements IActor{
public void basicAct(float money){
System.out.println("拿到钱，开始基本的表演："+money);
}
public void dangerAct(float money){
System.out.println("拿到钱，开始危险的表演："+money);
}
}public class Client {
public static void main(String[] args) {
//一个剧组找演员：
final Actor actor = new Actor();//直接
/**
* 代理：
* 间接。
* 获取代理对象：
* 要求：
* 被代理类最少实现一个接口
* 创建的方式
* Proxy.newProxyInstance(三个参数)
* 参数含义：
* ClassLoader：和被代理对象使用相同的类加载器。
* Interfaces：和被代理对象具有相同的行为。实现相同的接口。
* InvocationHandler：如何代理。
* 策略模式：使用场景是：
* 数据有了，目的明确。
* 如何达成目标，就是策略。
*
*/
IActor proxyActor = (IActor) Proxy.newProxyInstance(actor.getClass().getClassLoader(), actor.getClass().getInterfaces(), new InvocationHandler() {
/**
* 执行被代理对象的任何方法，都会经过该方法。
* 此方法有拦截的功能。
*
* 参数：
* proxy：代理对象的引用。不一定每次都用得到
* method：当前执行的方法对象
* args：执行方法所需的参数
* 返回值：
* 当前执行方法的返回值
*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {String name = method.getName();Float money = (Float) args[0];Object rtValue = null;//每个经纪公司对不同演出收费不一样，此处开始判断if("basicAct".equals(name)){//基本演出，没有 2000 不演if(money > 2000){//看上去剧组是给了 8000，实际到演员手里只有 4000//这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强rtValue = method.invoke(actor, money/2);}
}
if("dangerAct".equals(name)){//危险演出,没有 5000 不演if(money > 5000){//看上去剧组是给了 50000，实际到演员手里只有 25000//这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强rtValue = method.invoke(actor, money/2);}}return rtValue;}
});
//没有经纪公司的时候，直接找演员。
// actor.basicAct(1000f);
// actor.dangerAct(5000f);
//剧组无法直接联系演员，而是由经纪公司找的演员
proxyActor.basicAct(8000f);
proxyActor.dangerAct(50000f);
}
}
使用 CGLib 的 Enhancer 类创建代理对象
还是那个演员的例子，只不过不让他实现接口。
/**
* 一个演员
*/
public class Actor{//没有实现任何接口public void basicAct(float money){System.out.println("拿到钱，开始基本的表演："+money);
}
public void dangerAct(float money){System.out.println("拿到钱，开始危险的表演："+money);}
}
public class Client {
/**
* 基于子类的动态代理
* 要求：
* 被代理对象不能是最终类
* 用到的类：
* Enhancer
* 用到的方法：
* create(Class, Callback)
* 方法的参数：
* Class：被代理对象的字节码
* Callback：如何代理
* @param args
*/
public static void main(String[] args) {
final Actor actor = new Actor();
Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
new MethodInterceptor() {
/**
* 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
方法进行增强。
*
* 参数：
* 前三个和基于接口的动态代理是一样的。
* MethodProxy：当前执行方法的代理对象。
* 返回值：
* 当前执行方法的返回值
*/
@Override
public Object intercept(Object proxy, Method method, Object[] args,
MethodProxy methodProxy) throws Throwable {String name = method.getName();Float money = (Float) args[0];Object rtValue = null;if("basicAct".equals(name)){//基本演出if(money > 2000){rtValue = method.invoke(actor, money/2);}}if("dangerAct".equals(name)){//危险演出if(money > 5000){rtValue = method.invoke(actor, money/2);}}return rtValue;
}
});
cglibActor.basicAct(10000);
cglibActor.dangerAct(100000);
}
}
略。。。
spring 中的aop
AOP 相关术语
Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
Advice(通知/增强):所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
Target(目标对象):代理的目标对象。
Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程。spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
Proxy（代理）:一个类被 AOP 织入增强后，就产生一个结果代理类。
Aspect(切面):是切入点和通知（引介）的结合
基于xml的aop配置
环境搭建
拷贝必备的 jar 包到工程的 lib 目录
此处要拷贝 spring 的 ioc 和 aop 两组 jar 包
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mJEZvVqF-1617605762018)(E:\A_MyCodeLearnNote\TyproNoteUnload\javaee笔记\总结.assets\image-20200731212251905.png)]
创建 spring 的配置文件并导入约束
此处要导入 aop 的约束
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""xmlns:xsi=""xmlns:aop=""xsi:schemaLocation=" .xsd .xsd">
</beans>#####配置 spring 的 ioc
<!-- 配置 service -->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<property name="accountDao" ref="accountDao"></property>
</bean>
<!-- 配置 dao -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"><property name="dbAssit" ref="dbAssit"></property>
</bean>
<!-- 配置数据库操作对象 -->
<bean id="dbAssit" class="com.itheima.dbassit.DBAssit">
<property name="dataSource" ref="dataSource"></property>
<!-- 指定 connection 和线程绑定 -->
<property name="useCurrentConnection" value="true"></property>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property>
<property name="user" value="root"></property>
<property name="password" value="1234"></property>
</bean>抽取公共代码制作成通知
/**
* 事务控制类
* @Company
* @Version 1.0
*/
public class TransactionManager {
//定义一个 DBAssit
private DBAssit dbAssit ;
public void setDbAssit(DBAssit dbAssit) {this.dbAssit = dbAssit;
}
//开启事务
public void beginTransaction() {
try {dbAssit.getCurrentConnection().setAutoCommit(false);
} catch (SQLException e) {e.printStackTrace();
}
}//提交事务
public void commit() {
try {dbAssit.getCurrentConnection()mit();} catch (SQLException e) {e.printStackTrace();}
}//回滚事务
public void rollback() {
try {dbAssit.getCurrentConnection().rollback();
} catch (SQLException e) {e.printStackTrace();
}
}
//释放资源
public void release() {
try {dbAssit.releaseConnection();} catch (Exception e) {e.printStackTrace();}
}}配置步骤
第一步：把通知类用 bean 标签配置起来
<!-- 配置通知 -->
<bean id="txManager" class="com.itheima.utils.TransactionManager"><property name="dbAssit" ref="dbAssit"></property>
</bean>
第二步：使用 aop:config 声明 aop 配置
aop:config:
作用：用于声明开始 aop 的配置
<aop:config><!-- 配置的代码都写在此处 -->
</aop:config>第三步：使用 aop:aspect 配置切面
aop:aspect:
作用：
用于配置切面。
属性：
id：给切面提供一个唯一标识。
ref：引用配置好的通知类 bean 的 id。
<aop:aspect id="txAdvice" ref="txManager"><!--配置通知的类型要写在此处-->
</aop:aspect>
第四步：使用 aop:pointcut 配置切入点表达式
aop:pointcut：
作用：
用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。
属性：
expression：用于定义切入点表达式。
id：用于给切入点表达式提供一个唯一标识
<aop:pointcut expression="execution(
public void com.itheima.service.impl.AccountServiceImpl.transfer(
java.lang.String, java.lang.String, java.lang.Float)
)" id="pt1"/>
第五步：使用 aop:xxx 配置对应的通知类型
aop:before
作用：
用于配置前置通知。指定增强的方法在切入点方法之前执行
属性：
method:用于指定通知类中的增强方法名称
ponitcut-ref：用于指定切入点的表达式的引用
poinitcut：用于指定切入点表达式
执行时间点：
切入点方法执行之前执行
<aop:before method="beginTransaction" pointcut-ref="pt1"/>
aop:after-returning
作用：
用于配置后置通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
执行时间点：
切入点方法正常执行之后。它和异常通知只能有一个执行
<aop:after-returning method="commit" pointcut-ref="pt1"/>
aop:after-throwing
作用：
用于配置异常通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
执行时间点：
切入点方法执行产生异常后执行。它和后置通知只能执行一个
<aop:after-throwing method="rollback" pointcut-ref="pt1"/>
aop:after
作用：
用于配置最终通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
执行时间点：
无论切入点方法执行时是否有异常，它都会在其后面执行。
<aop:after method="release" pointcut-ref="pt1"/>
切入点表达式说明
execution:匹配方法的执行(常用)
execution(表达式)
表达式语法：execution([修饰符] 返回值类型 包名.类名.方法名(参数))
写法说明：
全匹配方式：
public void
com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
访问修饰符可以省略
void
com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)返回值可以使用*号，表示任意返回值
*
com.itheima.service.impl.AccountServiceImpl.saveAccount(com.itheima.domain.Account)
包名可以使用*号，表示任意包，但是有几级包，需要写几个*
* *.*.*.*.AccountServiceImpl.saveAccount(com.itheima.domain.Account)使用..来表示当前包，及其子包
* com..AccountServiceImpl.saveAccount(com.itheima.domain.Account)类名可以使用*号，表示任意类
* com..*.saveAccount(com.itheima.domain.Account)
方法名可以使用*号，表示任意方法
* com..*.*( com.itheima.domain.Account)参数列表可以使用*，表示参数可以是任意数据类型，但是必须有参数
* com..*.*(*)
参数列表可以使用..表示有无参数均可，有参数可以是任意类型
* com..*.*(..)
全通配方式：
* *..*.*(..)通常情况下，我们都是对业务层的方法进行增强，所以切入点表达式都是切到业务层实现类。
execution(* com.itheima.service.impl.*.*(..))
环绕通知
配置方式:
<aop:config>
<aop:pointcut expression="execution(* com.itheima.service.impl.*.*(..))"
id="pt1"/>
<aop:aspect id="txAdvice" ref="txManager"><!-- 配置环绕通知 --><aop:around method="transactionAround" pointcut-ref="pt1"/>
</aop:aspect>
</aop:config>
aop:around：
作用：
用于配置环绕通知
属性：
method：指定通知中方法的名称。
pointct：定义切入点表达式
pointcut-ref：指定切入点表达式的引用
说明：
它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。
注意：
通常情况下，环绕通知都是独立使用的
/**
* 环绕通知
* @param pjp
* spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参数。
* 在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
* @return
*/
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {//获取方法执行所需的参数Object[] args = pjp.getArgs();//前置通知：开启事务beginTransaction();//执行方法rtValue = pjp.proceed(args);//后置通知：提交事务commit();
}catch(Throwable e) {//异常通知：回滚事务rollback();e.printStackTrace();
}finally {//最终通知：释放资源release();
}return rtValue;
}基于注解的 AOP 配置
环境搭建
第一步：准备必要的代码和 jar 包
拷贝上一小节的工程即可
第二步：在配置文件中导入 context 的名称空间
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""
xmlns:aop=""
xmlns:context=""xmlns:xsi=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd://www.springframework/schema/aop/spring-aop.xsd://www.springframework/schema/context/spring-context.xsd">
<!-- 配置数据库操作对象 -->
<bean id="dbAssit" class="com.itheima.dbassit.DBAssit">
<property name="dataSource" ref="dataSource"></property>
<!-- 指定 connection 和线程绑定 -->
<property name="useCurrentConnection" value="true"></property>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property>
<property name="user" value="root"></property>
<property name="password" value="1234"></property>
</bean>
</beans>
/**
* 账户的业务层实现类
* @author 黑马程序员
* @Company
* @Version 1.0
*/
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
@Autowired
private IAccountDao accountDao;/**
* 账户的持久层实现类
* @author 黑马程序员
* @Company
* @Version 1.0
*/
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
@Autowired
private DBAssit dbAssit ;
}
第四步：在配置文件中指定 spring 要扫描的包
<!-- 告知 spring，在创建容器时要扫描的包 -->
<context:component-scan base-package="com.itheima"></context:component-scan>
配置步骤
第一步：把通知类也使用注解配置
/*** 事务控制类
* @author 黑马程序员
* @Company
* @Version 1.0*/@Component("txManager")public class TransactionManager {//定义一个 DBAssit@Autowiredprivate DBAssit dbAssit ;}
第二步：在通知类上使用@Aspect 注解声明为切面
作用：
把当前类声明为切面类。
/**
* 事务控制类
* @author 黑马程序员
* @Company
* @Version 1.0
*/
@Component("txManager")
@Aspect//表明当前类是一个切面类
public class TransactionManager {//定义一个 DBAssit@Autowiredprivate DBAssit dbAssit ;
}
第三步：在增强的方法上使用注解配置通知
@Before
作用：
把当前方法看成是前置通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。
//开启事务
@Before("execution(* com.itheima.service.impl.*.*(..))")
public void beginTransaction() {
try {
dbAssit.getCurrentConnection().setAutoCommit(false);
} catch (SQLException e) {
e.printStackTrace();
}
}
@AfterReturning
作用：
把当前方法看成是后置通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用
//提交事务
@AfterReturning("execution(* com.itheima.service.impl.*.*(..))")
public void commit() {try {dbAssit.getCurrentConnection()mit();} catch (SQLException e) {e.printStackTrace();}
}
@After
作用：
把当前方法看成是最终通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用
//释放资源
@After("execution(* com.itheima.service.impl.*.*(..))")
public void release() {
try {
dbAssit.releaseConnection();
} catch (Exception e) {
e.printStackTrace();
}
}第四步：在 spring 配置文件中开启 spring 对注解 AOP 的支持
第四步：在 spring 配置文件中开启 spring 对注解 AOP 的支持
<aop:aspectj-autoproxy/>
环绕通知注解配置
@Around("execution(* com.itheima.service.impl.*.*(..))")
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知：开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知：提交事务
commit();
}catch(Throwable e) {
//异常通知：回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知：释放资源
release();
}
return rtValue;
}切入点表达式注解
@Pointcut
作用：
指定切入点表达式
属性：value：指定表达式的内容
@Pointcut("execution(* com.itheima.service.impl.*.*(..))")
private void pt1() {}
引用方式：
/**
* 环绕通知
* @param pjp
* @return
*/
@Around("pt1()")//注意：千万别忘了写括号
public Object transactionAround(ProceedingJoinPoint pjp) {
//定义返回值
Object rtValue = null;
try {
//获取方法执行所需的参数
Object[] args = pjp.getArgs();
//前置通知：开启事务
beginTransaction();
//执行方法
rtValue = pjp.proceed(args);
//后置通知：提交事务
commit();
}catch(Throwable e) {
//异常通知：回滚事务
rollback();
e.printStackTrace();
}finally {
//最终通知：释放资源
release();
}
return rtValue;
}
不使用 XML 的配置方式
@Configuration
@ComponentScan(basePackages="com.itheima")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}
Spring 中的jdbctemplate
spring 配置数据源
配置 C3P0 数据源
导入 c3p0 jar包到工程的 lib 目录。在 spring 的配置文件中配置：
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"><property name="driverClass" value="com.mysql.jdbc.Driver"></property><property name="jdbcUrl" value="jdbc:mysql:///spring_day02"></property><property name="user" value="root"></property><property name="password" value="1234"></property>
</bean>
配置 DBCP 数据源
导入 到工程的 lib 目录。在 spring 的配置文件中配置：
<!-- 配置数据源 -->
<bean id="dataSource" class="org.apachemons.dbcp.BasicDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"></property><property name="url" value="jdbc:mysql:// /spring_day02"></property><property name="username" value="root"></property><property name="password" value="1234"></property>
</bean>
配置 spring 内置数据源
spring 框架也提供了一个内置数据源，我们也可以使用 spring 的内置数据源，它就在
spring-jdbc-5.0.2.REEASE.jar 包中：
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"></property><property name="url" value="jdbc:mysql:///spring_day02"></property><property name="username" value="root"></property><property name="password" value="1234"></property>
</bean>
####将数据库连接的信息配置到属性文件中:
【定义属性文件】
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_day02
jdbc.username=root
jdbc.password=123
【引入外部的属性文件】
一种方式:<!-- 引入外部属性文件： --><bean
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="location" value="classpath:jdbc.properties"/></bean>
另一种方式:
<context:property-placeholder location="classpath:jdbc.properties"/>
在spring中配置jdbctemplate
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd">
<!-- 配置一个数据库的操作模板：JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver"></property><property name="url" value="jdbc:mysql:///spring_day02"></property><property name="username" value="root"></property><property name="password" value="1234"></property>
</bean>
</beans>
更多推荐
spring基础总结
发布评论