spring框架实现

1.基础maven类型
- - 1.开发准备--pom.xml添加spring依赖
  - 2.创建properties文件
- 还是三层架构开发
- - 3.domain层创建实体类javabean
  - 4.dao层操作
  - 5.resources中对应dao配置文件添加
  - 6.业务层service开发
  - 7.spring环境配置文件
  - 8.运行一下子
2.纯注解开发型
- - 1.pom.xml添加依赖
  - 2.配置文件转换为配置类
- 三层架构包
- - 3.dao层
  - 4.service层
  - 5.还是实现一下
Aop开发
- 1.依赖添加
- 2.改写注解项目实现AOP
- 3.添加AOP类

本次介绍只基于后端，非web，转换成web就添加web层基于servlet进行前后端交互就可以了
这种虽然说是spring框架，但是都是基于maven进行开发，所以创建项目是创建一个maven项目，然后添加spring依赖进行基于spring框架进行开发

1.基础maven类型

基础maven类型，与maven框架开发差不多，只不过加入了spring依赖，其中内部逻辑是不变的，但是不同的是在spring中，xml配置文件连接service和dao层方式是不一样的，除此之外一模一样.
基础版架构:

1.开发准备–pom.xml添加spring依赖

maven项目开发第一步，添加依赖和插件，因为我们不是web项目，不需要添加tomcat插件，不过web和非web项目开发是一致的，没什么差别
pom.xml中需要添加的依赖

<dependencies><!--mybatis包--><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.3</version></dependency><!--连接mysql--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version></dependency><!--spring依赖包--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.1.9.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.1.9.RELEASE</version></dependency><!--线程池包--><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.16</version></dependency><!--mybatis-spring整合包(主要配置)--><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>1.3.0</version></dependency></dependencies>

2.创建properties文件

依赖环境添加好之后，我们就可以进行项目开发了，因为要进行数据库的操作，所以我们先创建一个数据库连接配置----里面的数据库名和用户密码设置自己的
创建一个jdbc.properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db
jdbc.username=root
jdbc.password=root

还是三层架构开发

因为没有前后端的交互,所以web层就没了,只有后端的dao层和service层

3.domain层创建实体类javabean

看看数据库里面有什么,哇,原来是这
三列,分别为id(int),name(string),money(double)–之后的案例也是用这个数据库

所以在domain层中创建一个实体类Account
因为只是简单介绍,里面直接添加tostring输出数据

public class Account implements Serializable {private Integer id;private String name;private Double money;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Double getMoney() {return money;}public void setMoney(Double money) {this.money = money;}@Overridepublic String toString() {return "Account{" +"id=" + id +", name='" + name + '\'' +", money=" + money +'}';}
}

4.dao层操作

创建了实体类,我们就可以创建dao层进行数据库操作了,在这里你想对数据库做什么就做什么
创建一个接口AccountDao,在里面我们进行对数据库的增删改查操作

public interface AccountDao {void save(Account account);void delete(Integer id);void update(Account account);List<Account> findAll();Account findById(Integer id);
}

这样一个简单的dao就搞定了,既然dao添加了相应方法,我们就得在对应的资源文件中进行数据库语句的添加

5.resources中对应dao配置文件添加

dao在哪我在哪,dao有啥我有啥
在resources对应dao层也搞一个对应AccountDao接口的AccountDao.xml文件,其实并不需要这样那样的,不过为了后续业务扩展更新,做成这样对应相应修改很直观简便,做项目架构很重要.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapperPUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dou.dao.AccountDao"><!--配置根据id查询--><select id="findById" resultType="account" parameterType="int">select * from spring where id = #{id}</select><!--配置查询所有--><select id="findAll" resultType="account">select * from spring</select><!--配置保存--><insert id="save" parameterType="account">insert into spring(name,money)values(#{name},#{money})</insert><!--配置删除--><delete id="delete" parameterType="int">delete from spring where id = #{id}</delete><!--配置根据名称查询--><select id="findByName" resultType="account" parameterType="string">select * from spring where name = #{name}</select><!--配置更新--><update id="update" parameterType="account">update spring set name=#{name},money=#{money} where id=#{id}</update>
</mapper>

6.业务层service开发

dao层搞好了,对应数据库连接也搞好了,接着就是业务层实现了,业务层怎么搞呢,
先做业务接口创建对应方法, 然后进行Impl业务逻辑实现
创建AccountService接口:

public interface AccountService {void save(Account account);void delete(Integer id);void update(Account account);List<Account> findAll();Account findById(Integer id);
}

然后在业务层中创建包Impl,这个主要是区分一下方法和实现,在Impl下创建AccountServiceImpl实现类,继承AccountService接口
因为没交互,所以…极其简单

public class AccountServiceImpl implements AccountService {private AccountDao accountDao;public void setAccountDao(AccountDao accountDao) {this.accountDao = accountDao;}public void save(Account account) {accountDao.save(account);}public void update(Account account){accountDao.update(account);}public void delete(Integer id) {accountDao.delete(id);}public Account findById(Integer id) {return  accountDao.findById(id);}public List<Account> findAll() {return  accountDao.findAll();}
}

7.spring环境配置文件

数据库也连接了,实现类也实现了,然后把spring的环境配置好就可以进行应用了
在resources下面创建一个applicationContext.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: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
"><!--加载配置文件 *号是是个properties文件我就加载--><context:property-placeholder location="classpath:*.properties"/><!--数据库信息--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driver}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/></bean><!--配置service作为spring的bean,注入dao--><bean id="accountService" class="com.dou.service.impl.AccountServiceImpl"><property name="accountDao" ref="accountDao"/></bean><!--spring整合mybatis后控制创建连接的对象--><bean  class="org.mybatis.spring.SqlSessionFactoryBean"><!--数据库连接--><property name="dataSource" ref="dataSource"/><!--domain起别名--><property name="typeAliasesPackage" value="com.dou.domain"/></bean><!--//扫描org.mybatis.spring.sample.mapper下的所有接口(各种增删改查等)，然后创建各自接口的动态代理类。--><bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="com.dou.dao"/></bean></beans>

里面是什么东西呢,就是以前maven项目中mapper映射文件里面的内容,可以对比一下,一毛一样(对比代码)

**maven----**<!--定义property的配置--><properties resource="jdbc.properties"></properties>
**spring----**
<!--加载配置文件--><context:property-placeholder location="classpath:*.properties"/>**maven----**<!--配置别名:别名配置是给实体类用的，不能用在dao上--><typeAliases><!--指定实体类所在的包，此时包下所有类都会注册别名，别名就是类名称--><package name="com.itheima.domain"></package></typeAliases>
**spring----**
<!--domain起别名--><property name="typeAliasesPackage" value="com.dou.domain"/>**maven----**<!--配置默认环境--><environments default="mysql"><!--配置mysql的环境--><environment id="mysql"><!--配置事务的类型--><transactionManager type="JDBC"></transactionManager><!--配置数据源信息--><dataSource type="POOLED" ><!--配置连接数据库的四个基本信息--><property name="driver" value="${jdbc.driver}"></property><property name="url" value="${jdbc.url}"></property><property name="username" value="${jdbc.username}"></property><property name="password" value="${jdbc.password}"></property></dataSource></environment></environments>
**spring----**
<!--数据库信息--><bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driver}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/></bean>**maven----**<!--配置映射配置文件的位置--><mappers><!--指定实体映射配置文件所在的包，指定的是dao接口所在的包--><package name="com.itheima.dao"></package></mappers>**spring----**<!--//扫描org.mybatis.spring.sample.mapper下的所有接口(各种增删改查等)，然后创建各自接口的动态代理类。--><bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="com.dou.dao"/></bean>

8.运行一下子

配置结束,随便写个main实现一下就行
在java下创建一个App类去连接配置文件,调用其中的方法,看看是不是实现了

public class App {public static void main(String[] args) {//连接配置文件ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");//获取对应Dao接口bean,类型需要强转为服务层接口类AccountService accountService= (AccountService) ctx.getBean("accountService");//方法实现://查看List<Account> all1 = accountService.findAll();System.out.println(all1);//保存Account account = new Account(2,"张飞",33.3);accountService.save(account);//单个查看Account ac1 = accountService.findById(2);System.out.println(ac1);//修改4,名字变成寒蝉account.setName("寒蝉");accountService.update(account);//单个查看Account ac2 = accountService.findById(2);System.out.println(ac2);//删除accountService.delete(2);//查看List<Account> all2 = accountService.findAll();System.out.println(all2);}
}

2.纯注解开发型

注释使我们人能看懂的
注解就是计算机能看懂的语言,用了注解计算机会自动判断识别并进行操作,简化代码

1.pom.xml添加依赖

这个是跟基础类型的依赖相同的,没有特殊添加,因为第一个把maven整合spring依赖加进去了,基础版是不需要的,主要是用于添加一些注解的

2.配置文件转换为配置类

配置文件全部以注解形式体现,注解就是为了消除配置文件,把resources中的文件全部消除

比如AccountDao.xml中的文件,是连接dao和数据库的窗口:

<!--配置根据id查询--><select id="findById" resultType="account" parameterType="int">select * from spring where id = #{id}</select><!--配置查询所有--><select id="findAll" resultType="account">select * from spring</select><!--配置保存--><insert id="save" parameterType="account">insert into spring(id,name,money)values(#{id},#{name},#{money})</insert><!--配置删除--><delete id="delete" parameterType="int">delete from spring where id = #{id}</delete><!--配置根据名称查询--><select id="findByName" resultType="account" parameterType="string">select * from spring where name = #{name}</select><!--配置更新--><update id="update" parameterType="account">update spring set name=#{name},money=#{money} where id=#{id}</update>

这些语句不用再创建类,直接用以前maven项目经验,在AccountDao接口中直接注解在接口方法上(没有什么好坏的说法,都一个熊样)

public interface AccountDao {@Insert("insert into spring (id,name,monry) values(#{id},#{name},#{monry})")void save(Account account);@Delete("delete from spring where id = #{id}")void delete(Integer id);@Update("update spring set name=#{name},money=#{money} where id=#{id}")void update(Account account);@Select("select * from spring")List<Account> findAll();@Select("select * from spring where id=#{id}")Account findById(Integer id);
}

然后是jdbc.properties文件了,里面是连接的数据库信息:

 jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db
jdbc.username=root
jdbc.password=root

这个文件比较特殊,所以就另外创建配置类添加信息
比如创建一个包config专门存放java配置类
然后在config包下创建一个JDBCConfig类,存放连接数据库的信息

public class JDBCConfig {//value设置对应属性的值(或对方法)进行传参@Value("com.mysql.jdbc.Driver")private  String driver;@Value("jdbc:mysql://localhost:3306/spring_db")private  String url;@Value("root")private  String username;@Value("root")private  String password;//设置该方法的返回值作为spring管理的bean,作用:连接数据库@Bean("dataSource")public DataSource DataSource(){DruidDataSource ds = new DruidDataSource();ds.setDriverClassName(driver);ds.setUrl(url);ds.setUsername(username);ds.setPassword(password);return ds;}
}

然后就是重点了,applicationContext.xml文件就不需要了,直接转换:

<!--加载配置文件-->           --不需要这个文件了,转换成配置类了,会直接在主配置类中加载<context:property-placeholder location="classpath:*.properties"/><!--数据库信息-->           --这个就转换到JDBCConfig类中                   <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driver}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${jdbc.username}"/><property name="password" value="${jdbc.password}"/></bean>                   --                  <!--配置service作为spring的bean,注入dao-->        <!--现在@Service("accountService")和@Autowired private AccountDao accountDao就可以实现引入类型注入,set方法也就不需要了;--><bean id="accountService" class="com.dou.service.impl.AccountServiceImpl"><property name="accountDao" ref="accountDao"/></bean><!--spring整合mybatis后控制创建连接的对象-->  --数据库连接也已经放进JDBCConfig配置类中去了<bean  class="org.mybatis.spring.SqlSessionFactoryBean"><!--数据库连接--><property name="dataSource" ref="dataSource"/><!--domain起别名-->   --放进了MyBatisConfig<property name="typeAliasesPackage" value="com.dou.domain"/></bean><!--//扫描org.mybatis.spring.sample.mapper下的所有接口(各种增删改查等)，然后创建各自接口的动态代理类。-->
--也放进了MyBatisConfig<bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer"><property name="basePackage" value="com.dou.dao"/></bean>
</beans>

转换成注解的话先在config包下创建一个核心配置类,例如SpringConfig,使用注解时要先在核心配置类添加@Configuration,设置项目开发为纯注解格式,设置当前类为spring核心配置加载类,其他次要第三方类直接集合形式导入,第三方类就例如JDBCCofig类,还有创建一个例如MyBatisConfig类,里面存放applicationContext中特殊形式的的信息,比如起别名和扫描dao下所有接口的信息,单独存放在一个配置类中,不破坏已有架构文件的结构

MyBatisConfig类:
重点之一,里面方法上注解为Bean,就是在运行时会被扫描器所扫描到的方法

public class MyBatisConfig {//消灭Xml文件(方法注解)--后续扫描@Beanpublic SqlSessionFactoryBean getSqlSessionFactory(@Autowired DataSource dataSource){SqlSessionFactoryBean ssfb=new SqlSessionFactoryBean();ssfb.setTypeAliasesPackage("com.dou.domain");ssfb.setDataSource(dataSource);return  ssfb;}@Beanpublic MapperScannerConfigurer getMapperScannerConfigurer(){MapperScannerConfigurer msc=new MapperScannerConfigurer();msc.setBasePackage("com.dou.dao");return  msc;}
}

然后就是SpringConfig配置类(特别重要):
这里设置为主配置类,因为写的东西特别少,所以里面并没有什么东西,在后续的开发中,如果需要什么配置可以直接填充,很方便.

//设置纯注解格式--设置当前类为spring核心配置加载类,其他次要第三方类直接集合形式导入
@Configuration
//bean扫描注解,扫描路径看仔细,是最上层路径*(替代context扫描)
@ComponentScan("com.dou")//加载properties文件,就是咱们常用的jdbc配置文件
//这个东西可以引入,或者直接建一个config配置类导入,下面就是用的直接导入import
/*@PropertySource("classpath:jdbc.properties")*/@Import({JDBCConfig.class,MyBatisConfig.class})
public class SpringConfig {}

三层架构包

跟基础型开发差不多,多理解就感觉一毛一样,直接贴代码了

3.dao层

AccountDao类

public interface AccountDao {@Insert("insert into spring (id,name,money) values(#{id},#{name},#{money})")void save(Account account);@Delete("delete from spring where id = #{id}")void delete(Integer id);@Update("update spring set name=#{name},money=#{money} where id=#{id}")void update(Account account);@Select("select * from spring")List<Account> findAll();@Select("select * from spring where id=#{id}")Account findById(Integer id);
}

4.service层

包括service接口和service实现类,一毛一样

AccountService接口

public interface AccountService {void save(Account account);void delete(Integer id);void update(Account account);List<Account> findAll();Account findById(Integer id);}

Impl包下的业务实现类AccountServiceImpl

//component同样适用 设置该类为spring管理的bean
@Service("accountService")
public class AccountServiceImpl implements AccountService {//设置对应属性的对象(或对方法)进行引用类型注入,以前用set注入,现在不需要了(参数)@Autowiredprivate AccountDao accountDao;public void save(Account account) {accountDao.save(account);}public void update(Account account){accountDao.update(account);}public void delete(Integer id) {accountDao.delete(id);}public Account findById(Integer id) {return  accountDao.findById(id);}public List<Account> findAll() {return  accountDao.findAll();}
}

5.还是实现一下

实现类中原本是用ClassPathXmlApplicationContext加载xml配置文件,现在注解形式不需要xml文件,直接加载主要配置类文件SpringConfig,使用AnnotationConfigApplicationContext加载

 public static void main(String[] args) {//xml配置加载ClassPathXmlApplicationContext/* ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");AccountService accountService= (AccountService) ctx.getBean("accountService");Account ac = accountService.findById(1);System.out.println(ac);*///配置文件类SpringConfig加载*(纯注解格式文件加载,跟加载xml配置文件不一样,为AnnotationConfigApplicationContext)ApplicationContext ctx=new AnnotationConfigApplicationContext(SpringConfig.class);AccountService accountService= (AccountService) ctx.getBean("accountService");//剩下的这是功能实现//方法实现://查看List<Account> all1 = accountService.findAll();System.out.println(all1);//保存Account account = new Account(2,"张飞",33.3);accountService.save(account);//单个查看Account ac1 = accountService.findById(2);System.out.println(ac1);//修改4,名字变成寒蝉account.setName("寒蝉");accountService.update(account);//单个查看Account ac2 = accountService.findById(2);System.out.println(ac2);//删除accountService.delete(2);//查看List<Account> all2 = accountService.findAll();System.out.println(all2);}
}

注解结束!!感谢我自己,谢谢谢谢,又浪费了时间,谢谢你

Aop开发

Aop开发好处很明显,解耦,减少内存使用,每段代码只需要把特有功能添加上去就可以了,公共功能可以设置before、after使用，也可以添加异常输出等等…也可以设置around，按源代码顺序去实现，

1.依赖添加

只需要在pom.xml中添加一个Aop依赖就行了

<!--导入Aop坐标--><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version></dependency>

2.改写注解项目实现AOP

改写时候不需要修改任何注解时的代码,只需要添加共性功能就行,代码太少不需要抽取什么东西
重点:在主要配置类SpringConfig中添加一个注解@EnableAspectJAutoProxy,设置开启AOP注解驱动的支持

@Configuration
@ComponentScan("com.dou")
/*@PropertySource("classpath:jdbc.properties")*/
@Import({JDBCConfig.class,MyBatisConfig.class})//设置当前类开启AOP注解驱动的支持，加载AOP注解--重点
@EnableAspectJAutoProxy
public class SpringConfig {}

3.添加AOP类

创建一个AOP的包,在里面添加aop方法
在AOP包下创建一个类RunTimeMonitorAdvice

//主--设置该类为spring管理的bean
@Component
//设置当前类为切面类
@Aspect
public class RunTimeMonitorAdvice {//切入点，监控业务层接口,Service结尾方法@Pointcut("execution(* com.dou.service.*Service.*(..))")public void pt(){}//所有注解必须加pt()方法,不然默认无切入//业务模块代码执行之前执行@Before("pt()")public void  before(){System.out.println("有业务我就开始");}//该注解标注的方法在业务模块代码执行之后执行//@AfterThrowing这个差不多的是报错执行,不写了@AfterReturning("pt()")public  void afterreturning(){System.out.println("这个业务代码执行完了");}//在所有的Advice执行完成后执行,类似finally@After("pt()")public void after(){System.out.println("这个执行完了");}//环绕通知,用于调用业务模块的代码，--重点,切入是一个一个方法切入,不是一次全部方法切入// 无论是调用前逻辑还是调用后逻辑，都可以在该方法中编写，// 甚至其可以根据一定的条件而阻断业务模块的调用；@Around("pt()")public Object runtimeAround(ProceedingJoinPoint pjp) throws Throwable {//获取执行签名信息Signature signature = pjp.getSignature();//通过签名获取执行类型（接口名）String className = signature.getDeclaringTypeName();//通过签名获取执行操作名称（方法名）String methodName = signature.getName();//这行代码是重点,调用业务层方法进行执行,没有它就没有新世界Object ret = pjp.proceed(pjp.getArgs());System.out.println(ret);//执行时长累计值long sum = 0L;//获取操作前系统时间beginTimelong startTime = System.currentTimeMillis();/*//原始操作调用--傻帽操作,谁写的pjp.proceed(pjp.getArgs());*///获取操作后系统时间endTimelong endTime = System.currentTimeMillis();sum += endTime-startTime;//打印信息System.out.println(className+":"+methodName+"执行时间run:"+sum+"ms");return ret;}
}

@before和@after他们是内部执行
App的main方法输出是在最最后的,不要搞混了

spring框架三种类型项目实现--基础maven类型、纯注解开发型、aop结合注解开发型相关推荐

Spring的三种注入方式（为什么推荐构造器注入？）
Spring的三种注入方式一.属性注入 @Resource和@Autowired的区别为什么尽量使用 @Resource? 二.setter 注入三.构造器注入具体可以看看Spring官网为 ...
Spring 异常处理三种方式
Spring 异常处理三种方式异常处理方式一. @ExceptionHandler 异常处理方式二. 实现HandlerExceptionResolver接口异常处理方式三. @Controlle ...
（转）Spring的三种实例化Bean的方式
http://blog.csdn.net/yerenyuan_pku/article/details/52832793 Spring提供了三种实例化Bean的方式. 使用类构造器实例化. <be ...
tomcat中三种部署项目的方法（转）
tomcat中三种部署项目的方法第一种方法:在tomcat中的conf目录中,在server.xml中的,<host/>节点中添加: <Context path="/h ...
Spring的三种事务控制
Spring的三种方式的事务控制 1:基于编程式的事务控制 1.1:编程式事务控制相关对象 PlatformTransactionManager接口是spring的事务管理器,他里面提供了我们常用的操 ...
J2EE高级开发框架小课程之Spring框架1——Spring创建三种方式：使用无参构造器创建对象（bean标签的方式），使用静态方法创建对象，使用实例方法创建对象（非静态方法）
Spring是什么? 是一个开源的.用于简化企业级应用开发的应用开发框架. a.简化开发: Spring框架对很多常用的api做了简化,比如,使用Spring jdbc (Spring jdbc是Sp ...
python三种数据类型_Python零基础入门学习02：Python基本数据类型：数字类型
注 :本文所有代码均经过Python 3.7实际运行检验,保证其严谨性. Python学习 Python有三种不同的数字类型:整数(int),浮点数(float)和复数(complex). 值得注意的 ...
spring boot 三种类型事物实现说明
首先需要了解的是spring boot 对事物的分类 1: JDBC 事物引入依赖包 spring-boot-starter-jdbc jdbc事物是传统方式,直接连接数据库进行操作. 需要增加配置 ...
Spring框架（JavaEE开发进阶Ⅲ）—基础和IoC
一.Spring简介 1.Spring的诞生 1.1.原因日益复杂的Java企业应用开发 1.2.EJB之殇 JavaSE1.3引入了动态代理,使EJB采用的容器代码生成机制过时当时AOP编程获得 ...

spring框架三种类型项目实现--基础maven类型、纯注解开发型、aop结合注解开发型