框架 订阅
框架(framework)是一个框子——指其约束性,也是一个架子——指其支撑性。是一个基本概念上的结构,用于去解决或者处理复杂的问题。框架这个广泛的定义使用的十分流行,尤其在软件概念。框架也能用于机械结构。 展开全文
框架(framework)是一个框子——指其约束性,也是一个架子——指其支撑性。是一个基本概念上的结构,用于去解决或者处理复杂的问题。框架这个广泛的定义使用的十分流行,尤其在软件概念。框架也能用于机械结构。
信息
注    音
ㄎㄨㄤˋ ㄐㄧㄚˋ
拼    音
kuàng jià
英    译
Framework
释    义
联结而成的结构
中文名
框架
应用领域
软件、机械结构等
框架释义
1、释义:(1)建筑工程中,由梁、柱等联结而成的结构;(2)比喻事物的组织、结构。2、土木工程中,由梁、柱等构件刚性连结而成的结构体系。3、比喻事物的组织、结构:这部长篇小说已经有了一个大致的框架。
收起全文
精华内容
下载资源
问答
  • Spring框架介绍及使用

    万次阅读 多人点赞 2018-03-17 10:49:54
    Spring框架—控制反转(IOC) 1 Spring框架概述 1.1 什么是Spring 1.2 Spring的优点 1.3 Spring的体系结构 2 入门案例:(IoC) 2.1导入jar包 2.2目标类 2.3 配置文件 2.4测试 3 入门案例:DI 3.1 目标类...

    Spring框架—控制反转(IOC)

    1 Spring框架概述

    1.1 什么是Spring

    Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。Spring的核心是控制反转(IoC)和面向切面(AOP)。简单来说,Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。

    1.2 Spring的优点
    • 方便解耦,简化开发 (高内聚低耦合)
      Spring就是一个大工厂(容器),可以将所有对象创建和依赖关系维护,交给Spring管理
      spring工厂是用于生成bean
    • AOP编程的支持
      Spring提供面向切面编程,可以方便的实现对程序进行权限拦截、运行监控等功能
    • 声明式事务的支持
      只需要通过配置就可以完成对事务的管理,而无需手动编程
    • 方便程序的测试
      Spring对Junit4支持,可以通过注解方便的测试Spring程序
    • 方便集成各种优秀框架
      Spring不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如:Struts、Hibernate、MyBatis、Quartz等)的直接支持
    • 降低JavaEE API的使用难度
      Spring 对JavaEE开发中非常难用的一些API(JDBC、JavaMail、远程调用等),都提供了封装,使这些API应用难度大大降低
    1.3 Spring的体系结构

    这里写图片描述

    2 入门案例:(IoC)

    2.1导入jar包
    • 4 + 1 : 4个核心(beans、core、context、expression) + 1个依赖(commons-loggins…jar)
      这里写图片描述
      这里写图片描述
    2.2目标类
    • 提供UserService接口和实现类
    • 获得UserService实现类的实例
      之前开发中,直接new一个对象即可。学习spring之后,将由Spring创建对象实例–> IoC 控制反转(Inverse of Control)
      之后需要实例对象时,从spring工厂(容器)中获得,需要将实现类的全限定名称配置到xml文件中
    public interface UserService {
    	public void addUser();
    }
    public class UserServiceImpl implements UserService {
    	@Override
    	public void addUser() {
    		System.out.println("a_ico add user");
    	}
    }
    
    2.3 配置文件
    • 位置:任意,开发中一般在classpath下(src)
    • 名称:任意,开发中常用applicationContext.xml
    • 内容:添加schema约束
      约束文件位置:spring-framework-3.2.0.RELEASE\docs\spring-framework-reference\html\ xsd-config.html
    <?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">
    	<!-- 配置service 
    		<bean> 配置需要创建的对象
    			id :用于之后从spring容器获得实例时使用的
    			class :需要创建实例的全限定类名
    	-->
    	<bean id="userServiceId" class="com.itheima.a_ioc.UserServiceImpl"></bean>
    </beans>
    
    2.4测试
       @Test
    	public void demo02(){
    		//从spring容器获得
    		//1 获得容器
    		String xmlPath = "com/itheima/a_ioc/beans.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    		//2获得内容 --不需要自己new,都是从spring容器获得
    		UserService userService = (UserService) applicationContext.getBean("userServiceId");
    		userService.addUser();	
    

    3 入门案例:DI

    • 例如:
      class BookServiceImpl{
          //之前开发:接口 = 实现类  (service和dao耦合)
      	//private BookDao bookDao = new BookDaoImpl();
      	//spring之后 (解耦:service实现类使用dao接口,不知道具体的实现类)
      	private BookDao bookDao;
      	setter方法
      

    }
    模拟spring执行过程
    创建service实例:BookService bookService = new BookServiceImpl() -->IoC
    创建dao实例:BookDao bookDao = new BookDaoImple() -->IoC
    将dao设置给service:bookService.setBookDao(bookDao); -->DI

    ##### 3.1 目标类
    - 创建BookService接口和实现类
    - 创建BookDao接口和实现类
    - 将dao和service配置 xml文件
    - 使用api测试
    ##### 3.2 dao
    ```java
    public interface BookDao {
      public void save();
    }
    public class BookDaoImpl implements BookDao {
    
      @Override
      public void save() {
      	System.out.println("di  add book");
      }
    }
    
    3.3 service
    public interface BookService {
    
    	public abstract void addBook();
    
    }
    public class BookServiceImpl implements BookService {
    	
    	// 方式1:之前,接口=实现类
    //	private BookDao bookDao = new BookDaoImpl();
    	// 方式2:接口 + setter
    	private BookDao bookDao;
    	public void setBookDao(BookDao bookDao) {
    		this.bookDao = bookDao;
    	}
    	
    	@Override
    	public void addBook(){
    		this.bookDao.save();
    	}
    
    }
    
    3.4 配置文件
    <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">
    	<!-- 
    	模拟spring执行过程
    		创建service实例:BookService bookService = new BookServiceImpl()	IoC  <bean>
    		创建dao实例:BookDao bookDao = new BookDaoImpl()			IoC
    		将dao设置给service:bookService.setBookDao(bookDao);		DI   <property>
    		
    		<property> 用于进行属性注入
    			name: bean的属性名,通过setter方法获得
    				setBookDao ##> BookDao  ##> bookDao
    			ref :另一个bean的id值的引用
    	 -->
    
    	<!-- 创建service -->
    	<bean id="bookServiceId" class="com.itheima.b_di.BookServiceImpl">
    		<property name="bookDao" ref="bookDaoId"></property>
    	</bean>
    	
    	<!-- 创建dao实例 -->
    	<bean id="bookDaoId" class="com.itheima.b_di.BookDaoImpl"></bean>
    	
    
    </beans>
    
    3.5 测试
    	@Test
    	public void demo01(){
    		//从spring容器获得
    		String xmlPath = "com/itheima/b_di/beans.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    		BookService bookService = (BookService) applicationContext.getBean("bookServiceId");	
    		bookService.addBook();
    	}
    

    4 依赖注入装配Bean 基于xml

    4.1属性依赖注入
    • 依赖注入方式:手动装配 和 自动装配
      • 手动装配:一般进行配置信息都采用手动
        基于xml装配:构造方法、setter方法
      • 基于注解装配:
    4.1.1 构造方法

    目标类

    public class User {
    	
    	private Integer uid;
    	private String username;
    	private Integer age;
    	
    	public User(Integer uid, String username) {
    		super();
    		this.uid = uid;
    		this.username = username;
    	}
    	
    	public User(String username, Integer age) {
    		super();
    		this.username = username;
    		this.age = age;
    	}
    	
    

    spring配置

    	<!-- 构造方法注入 
    		* <constructor-arg> 用于配置构造方法一个参数argument
    			name :参数的名称
    			value:设置普通数据
    			ref:引用数据,一般是另一个bean id值
    			
    			index :参数的索引号,从0开始 。如果只有索引,匹配到了多个构造方法时,默认使用第一个。
    			type :确定参数类型
    		例如:使用名称name
    			<constructor-arg name="username" value="jack"></constructor-arg>
    			<constructor-arg name="age" value="18"></constructor-arg>
    		例如2:【类型type 和  索引 index】
    			<constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
    			<constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
    	-->
    	<bean id="userId" class="com.itheima.f_xml.a_constructor.User" >
    		<constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
    		<constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
    	</bean>
    
    4.1.2 setter方法
    <!-- setter方法注入 
    		* 普通数据 
    			<property name="" value="值">
    			等效
    			<property name="">
    				<value>* 引用数据
    			<property name="" ref="另一个bean">
    			等效
    			<property name="">
    				<ref bean="另一个bean"/>
    	
    	-->
    	<bean id="personId" class="com.itheima.f_xml.b_setter.Person">
    		<property name="pname" value="阳志"></property>
    		<property name="age">
    			<value>1234</value>
    		</property>
    		
    		<property name="homeAddr" ref="homeAddrId"></property>
    		<property name="companyAddr">
    			<ref bean="companyAddrId"/>
    		</property>
    	</bean>
    	
    	<bean id="homeAddrId" class="com.itheima.f_xml.b_setter.Address">
    		<property name="addr" value="阜南"></property>
    		<property name="tel" value="911"></property>
    	</bean>
    	<bean id="companyAddrId" class="com.itheima.f_xml.b_setter.Address">
    		<property name="addr" value="北京八宝山"></property>
    		<property name="tel" value="120"></property>
    	</bean>
    
    4.2 集合依赖注入
    <!-- 
    		集合的注入都是给<property>添加子标签
    			数组:<array>
    			List:<list>
    			Set:<set>
    			Map:<map> ,map存放k/v 键值对,使用<entry>描述
    			Properties:<props>  <prop key=""></prop>  【】
    			
    		普通数据:<value>
    		引用数据:<ref>
    	-->
    	<bean id="collDataId" class="com.itheima.f_xml.e_coll.CollData" >
    		<property name="arrayData">
    			<array>
    				<value>DS</value>
    				<value>DZD</value>
    				<value>屌丝</value>
    				<value>屌中屌</value>
    			</array>
    		</property>
    		
    		<property name="listData">
    			<list>
    				<value>于嵩楠</value>
    				<value>曾卫</value>
    				<value>杨煜</value>
    				<value>曾小贤</value>
    			</list>
    		</property>
    		
    		<property name="setData">
    			<set>
    				<value>停封</value>
    				<value>薄纸</value>
    				<value>关系</value>
    			</set>
    		</property>
    		
    		<property name="mapData">
    			<map>
    				<entry key="jack" value="杰克"></entry>
    				<entry>
    					<key><value>rose</value></key>
    					<value>肉丝</value>
    				</entry>
    			</map>
    		</property>
    		
    		<property name="propsData">
    			<props>
    				<prop key="高富帅"></prop>
    				<prop key="白富美"></prop>
    				<prop key="男屌丝"></prop>
    			</props>
    		</property>
    	</bean>
    

    5 依赖注入装配Bean 基于注解

    • 注解:就是一个类,使用@注解名称
    • 开发中:使用注解 取代 xml配置文件。
      1.@Component取代<bean class="">
      @Component("id") 取代 <bean id="" class="">
      2.web开发,提供3个@Component注解衍生注解(功能一样)取代
      @Repository :dao层
      @Service:service层
      @Controller:web层
      3.依赖注入,给私有字段设值,也可以给setter方法设值
      • 普通值:@Value(" ")
      • 引用值:
        方式1:按照【类型】注入 @Autowired 方式2:按照【名称】注入1 @Autowired @Qualifier("名称") 方式3:按照【名称】注入2 @Resource("名称")
        4.生命周期
        初始化:@PostConstruct 销毁:@PreDestroy
        5.作用域
        @Scope("prototype") 多例
        注解使用前提,添加命名空间,让spring扫描含有注解类
      
      <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 
         					   http://www.springframework.org/schema/beans/spring-beans.xsd
         					   http://www.springframework.org/schema/context 
         					   http://www.springframework.org/schema/context/spring-context.xsd">
      <!-- 组件扫描,扫描含有注解的类 -->
      <context:component-scan base-package="com.itheima.g_annotation.a_ioc"></context:component-scan>
      
    ```
    

    Spring框架—面向切面编程(AOP)

    1 什么是AOP

    • 在软件业,AOP为Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP(面向对象编程)的延续,是软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
    • AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码
    • 经典应用:事务管理、性能监视、安全检查、缓存 、日志等
    • Spring AOP使用纯Java实现,不需要专门的编译过程和类加载器,在运行期通过代理方式向目标类织入增强代码
    • AspectJ是一个基于Java语言的AOP框架,Spring2.0开始,Spring AOP引入对Aspect的支持,AspectJ扩展了Java语言,提供了一个专门的编译器,在编译时提供横向代码的织入

    2 AOP实现原理

    • aop底层将采用代理机制进行实现。
    • 接口 + 实现类 :spring采用 jdk 的动态代理Proxy。
    • 实现类:spring 采用 cglib字节码增强。

    3 AOP术语【掌握】

    1.target:目标类,需要被代理的类。例如:UserService
    2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如:所有的方法
    3.PointCut 切入点:已经被增强的连接点。例如:addUser()
    4.advice 通知/增强,增强代码。例如:after、before
    5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
    6.proxy 代理类
    7. Aspect(切面): 是切入点pointcut和通知advice的结合
    一个线是一个特殊的面。
    一个切入点和一个通知,组成成一个特殊的面。
    这里写图片描述

    4 AOP实现方式

    4.1手动方式

    4.1.1JDK动态代理
    • JDK动态代理 对“装饰者”设计模式 简化。使用前提:必须有接口

    1.目标类:接口 + 实现类

    public interface UserService {
    	public void addUser();
    	public void updateUser();
    	public void deleteUser();
    }
    

    2.切面类:用于存通知 MyAspect

    public class MyAspect {	
    	public void before(){
    		System.out.println("鸡首");
    	}	
    	public void after(){
    		System.out.println("牛后");
    	}
    }
    

    3.工厂类:编写工厂生成代理

    public class MyBeanFactory {
    	
    	public static UserService createService(){
    		//1 目标类
    		final UserService userService = new UserServiceImpl();
    		//2切面类
    		final MyAspect myAspect = new MyAspect();
    		/* 3 代理类:将目标类(切入点)和 切面类(通知) 结合 --> 切面
    		 * 	Proxy.newProxyInstance
    		 * 		参数1:loader ,类加载器,动态代理类 运行时创建,任何类都需要类加载器将其加载到内存。
    		 * 			一般情况:当前类.class.getClassLoader();
    		 * 					目标类实例.getClass().get...
    		 * 		参数2:Class[] interfaces 代理类需要实现的所有接口
    		 * 			方式1:目标类实例.getClass().getInterfaces()  ;注意:只能获得自己接口,不能获得父元素接口
    		 * 			方式2:new Class[]{UserService.class}   
    		 * 			例如:jdbc 驱动  --> DriverManager  获得接口 Connection
    		 * 		参数3:InvocationHandler  处理类,接口,必须进行实现类,一般采用匿名内部
    		 * 			提供 invoke 方法,代理类的每一个方法执行时,都将调用一次invoke
    		 * 				参数31:Object proxy :代理对象
    		 * 				参数32:Method method : 代理对象当前执行的方法的描述对象(反射)
    		 * 					执行方法名:method.getName()
    		 * 					执行方法:method.invoke(对象,实际参数)
    		 * 				参数33:Object[] args :方法实际参数
    		 * 
    		 */
    		UserService proxService = (UserService)Proxy.newProxyInstance(
    								MyBeanFactory.class.getClassLoader(), 
    								userService.getClass().getInterfaces(), 
    								new InvocationHandler() {
    									
    									@Override
    									public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    										
    										//前执行
    										myAspect.before();
    										
    										//执行目标类的方法
    										Object obj = method.invoke(userService, args);
    										
    										//后执行
    										myAspect.after();
    										
    										return obj;
    									}
    								});
    		
    		return proxService;
    	}
    
    }
    

    4.测试

    @Test
    	public void demo01(){
    		UserService userService = MyBeanFactory.createService();
    		userService.addUser();
    		userService.updateUser();
    		userService.deleteUser();
    	}
    
    4.1.2 CGLIB字节码增强
    • 没有接口,只有实现类。
    • 采用字节码增强框架 cglib,在运行时 创建目标类的子类,从而对目标类进行增强。

    工厂类

    public class MyBeanFactory {
    	
    	public static UserServiceImpl createService(){
    		//1 目标类
    		final UserServiceImpl userService = new UserServiceImpl();
    		//2切面类
    		final MyAspect myAspect = new MyAspect();
    		// 3.代理类 ,采用cglib,底层创建目标类的子类
    		//3.1 核心类
    		Enhancer enhancer = new Enhancer();
    		//3.2 确定父类
    		enhancer.setSuperclass(userService.getClass());
    		/* 3.3 设置回调函数 , MethodInterceptor接口 等效 jdk InvocationHandler接口
    		 * 	intercept() 等效 jdk  invoke()
    		 * 		参数1、参数2、参数3:以invoke一样
    		 * 		参数4:methodProxy 方法的代理
    		 * 		
    		 * 
    		 */
    		enhancer.setCallback(new MethodInterceptor(){
    
    			@Override
    			public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    				
    				//前
    				myAspect.before();
    				
    				//执行目标类的方法
    				Object obj = method.invoke(userService, args);
    				// * 执行代理类的父类 ,执行目标类 (目标类和代理类 父子关系)
    				methodProxy.invokeSuper(proxy, args);
    				
    				//后
    				myAspect.after();
    				
    				return obj;
    			}
    		});
    		//3.4 创建代理
    		UserServiceImpl proxService = (UserServiceImpl) enhancer.create();
    		
    		return proxService;
    	}
    
    }
    

    4.2半自动

    • 让spring 创建代理对象,从spring容器中手动的获取代理对象
    4.2.1目标类
    public interface UserService {
    	public void addUser();
    	public void updateUser();
    	public void deleteUser();
    }
    
    4.2.2切面类
    /**
     * 切面类中确定通知,需要实现不同接口,接口就是规范,从而就确定方法名称。
     * * 采用“环绕通知” MethodInterceptor
     *
     */
    public class MyAspect implements MethodInterceptor {
    
    	@Override
    	public Object invoke(MethodInvocation mi) throws Throwable {
    		
    		System.out.println("前3");
    		
    		//手动执行目标方法
    		Object obj = mi.proceed();
    		
    		System.out.println("后3");
    		return obj;
    	}
    }
    
    4.2.3Spring 配置
    <!-- 1 创建目标类 -->
    	<bean id="userServiceId" class="com.itheima.b_factory_bean.UserServiceImpl"></bean>
    	<!-- 2 创建切面类 -->
    	<bean id="myAspectId" class="com.itheima.b_factory_bean.MyAspect"></bean>
    
    	<!-- 3 创建代理类 
    		* 使用工厂bean FactoryBean ,底层调用 getObject() 返回特殊bean
    		* ProxyFactoryBean 用于创建代理工厂bean,生成特殊代理对象
    			interfaces : 确定接口们
    				通过<array>可以设置多个值
    				只有一个值时,value=""
    			target : 确定目标类
    			interceptorNames : 通知 切面类的名称,类型String[],如果设置一个值 value=""
    			optimize :强制使用cglib
    				<property name="optimize" value="true"></property>
    		底层机制
    			如果目标类有接口,采用jdk动态代理
    			如果没有接口,采用cglib 字节码增强
    			如果声明 optimize = true ,无论是否有接口,都采用cglib
    		
    	-->
    	<bean id="proxyServiceId" class="org.springframework.aop.framework.ProxyFactoryBean">
    		<property name="interfaces" value="com.itheima.b_factory_bean.UserService"></property>
    		<property name="target" ref="userServiceId"></property>
    		<property name="interceptorNames" value="myAspectId"></property>
    	</bean>
    
    4.2.4 测试
    	@Test
    	public void demo01(){
    		String xmlPath = "com/itheima/b_factory_bean/beans.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    		
    		//获得代理类
    		UserService userService = (UserService) applicationContext.getBean("proxyServiceId");
    		userService.addUser();
    		userService.updateUser();
    		userService.deleteUser();
    	}
    

    4.3全自动

    • 从spring容器获得目标类,如果配置aop,spring将自动生成代理。
    4.3.1 Spring配置
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xsi:schemaLocation="http://www.springframework.org/schema/beans 
           					   http://www.springframework.org/schema/beans/spring-beans.xsd
           					   http://www.springframework.org/schema/aop 
           					   http://www.springframework.org/schema/aop/spring-aop.xsd">
    	<!-- 1 创建目标类 -->
    	<bean id="userServiceId" class="com.itheima.c_spring_aop.UserServiceImpl"></bean>
    	<!-- 2 创建切面类(通知) -->
    	<bean id="myAspectId" class="com.itheima.c_spring_aop.MyAspect"></bean>
    	<!-- 3 aop编程 
    		3.1 导入命名空间
    		3.2 使用 <aop:config>进行配置
    				proxy-target-class="true" 声明时使用cglib代理
    			<aop:pointcut> 切入点 ,从目标对象获得具体方法
    			<aop:advisor> 特殊的切面,只有一个通知 和 一个切入点
    				advice-ref 通知引用
    				pointcut-ref 切入点引用
    		3.3 切入点表达式
    			execution(* com.itheima.c_spring_aop.*.*(..))
    			选择方法         返回值任意   包             类名任意   方法名任意   参数任意
    		
    	-->
    	<aop:config proxy-target-class="true">
    		<aop:pointcut expression="execution(* com.itheima.c_spring_aop.*.*(..))" id="myPointCut"/>
    		<aop:advisor advice-ref="myAspectId" pointcut-ref="myPointCut"/>
    	</aop:config>
    </beans>
    
    4.3.2 测试
    	@Test
    	public void demo01(){
    		String xmlPath = "com/itheima/c_spring_aop/beans.xml";
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
    		
    		//获得目标类
    		UserService userService = (UserService) applicationContext.getBean("userServiceId");
    		userService.addUser();
    		userService.updateUser();
    		userService.deleteUser();
    	}
    
    展开全文
  • 初识Spring Boot框架

    万次阅读 多人点赞 2016-12-19 20:42:04
    前面的铺垫文章已经连着写了六篇了,主要是介绍了Spring和SpringMVC框架,小伙伴们在学习的过程中大概也发现了这两个框架需要我们手动配置的地方非常多,不过做JavaEE开发的小伙伴们肯定也听说过“约定大于配置”...

    关注公众号【江南一点雨】,专注于 Spring Boot+微服务以及前后端分离等全栈技术,定期视频教程分享,关注后回复 Java ,领取松哥为你精心准备的 Java 干货!

    前面的铺垫文章已经连着写了六篇了,主要是介绍了Spring和SpringMVC框架,小伙伴们在学习的过程中大概也发现了这两个框架需要我们手动配置的地方非常多,不过做JavaEE开发的小伙伴们肯定也听说过“约定大于配置”这样一句话,就是说系统,类库,框架应该假定合理的默认值,而非要求提供不必要的配置,可是使用Spring或者SpringMVC的话依然有许多这样的东西需要我们进行配置,这样不仅徒增工作量而且在跨平台部署时容易出问题。OK,由于这些已经存在的问题,Spring Boot应运而生,使用Spring Boot可以让我们快速创建一个基于Spring的项目,而让这个Spring项目跑起来我们只需要很少的配置就可以了。Spring Boot主要有如下核心功能:

    1.独立运行的Spring项目

    Spring Boot可以以jar包的形式来运行,运行一个Spring Boot项目我们只需要通过java -jar xx.jar类运行。非常方便。

    2.内嵌Servlet容器

    Spring Boot可以内嵌Tomcat,这样我们无需以war包的形式部署项目。

    3.提供starter简化Maven配置

    使用Spring或者SpringMVC我们需要添加大量的依赖,而这些依赖很多都是固定的,这里Spring Boot 通过starter能够帮助我们简化Maven配置。

    4.自动配置Spring
    5.准生产的应用监控
    6.无代码生成和xml配置

    OK,关于SpringBoot更详细的优缺点小伙伴们也可以自行搜索,我这里不再罗列,我们还是来看看代码。
    #项目创建
    初次接触,我们先来看看如何创建一个Spring Boot项目,这里以IntelliJ IDEA为例,其他的IDE工具小伙伴们自行搜索创建方式:

    首先创建一个项目,创建时选择Spring Initializr,然后Next,如下图:

    这里写图片描述

    填写项目信息,如下图:

    这里写图片描述

    填写项目使用到的技术,上面的Spring Boot版本建议选择最新的稳定版,下面勾选上Web就可以了,如下图:

    这里写图片描述

    最后一步,填写工程名字点击finish:

    这里写图片描述
    OK,第一次创建时系统会去下载需要的依赖等,耗时稍长,以后每次都会很快创建好。
    OK,项目创建成功之后接下来我们来看看这个东西要怎么样去运行。首先我们看到在项目创建成功之后,在项目的根目录下会有一个artifactId+Application命名规则的入口类,如下图:
    这里写图片描述,就是这个Test19SpringBoot2Application类,这是我们整个项目的入口类,这个类有一个@SpringBootApplication注解,这是整个Spring Boot的核心注解,它的目的就是开启Spring Boot的自动配置。OK,那么我在这个类上再添加一个@RestController注解,使之变为一个Controller,然后里边提供一个地址转换方法,如下:

    @RestController
    @SpringBootApplication
    public class Test19SpringBoot2Application {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Test19SpringBoot2Application.class, args);
    	}
    
    	@RequestMapping(value = "/",produces = "text/plain;charset=UTF-8")
    	String index(){
    		return "Hello Spring Boot!";
    	}
    }
    

    然后点击项目启动按钮运行,在IntelliJ中就是这个按钮:
    这里写图片描述
    启动成功之后我们就可以直接在浏览器中访问了,如下:
    这里写图片描述
    OK,至此,我们一个简单的Spring Boot工程已经创建出来了,并且成功的从浏览器中访问到了,但是为什么它最终会跑起来呢?想必小伙伴们还有许多疑问,我们来分析下。
    #入口类和@SpringBootApplication注解

    上文说过,我们新建一个Project系统都会帮我们创建一个名为artifactId+Application的入口类,这个类中有一个main方法,这个main方法就是一个标准的Java应用程序的入口方法。而这里的@SpringBootApplication则是一个组合注解,我们可以看看它的源码:

    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(
        excludeFilters = {@Filter(
        type = FilterType.CUSTOM,
        classes = {TypeExcludeFilter.class}
    )}
    )
    public @interface SpringBootApplication {
    
    }
    

    我们可以看到它组合了@SpringBootConfiguration、@EnableAutoConfiguration以及@ComponentScan,我们在开发的过程中如果不使用@SpringBootApplication,则可以组合使用这三个注解。这三个注解中,@SpringBootConfiguration实际上就是我们前面几篇博客提到的@Configuration注解,表明这个类是一个配置类,@EnableAutoConfiguration则表示让Spring Boot根据类路径中的jar包依赖为当前项目进行自动配置,最后一个@ComponentScan的作用我也不赘述了,唯一要注意的是如果我们使用了@SpringBootApplication注解的话,系统会去入口类的同级包以及下级包中去扫描实体类,因此我们建议入口类的位置在groupId+arctifactID组合的包名下。

    #关闭特定的自动配置
    在上面一小节中我们看到@ComponentScan注解是有一个过滤器的,如果我们只想要@SpringBootApplication去扫描特定的类而不是全部类,那么就可以关闭自动配置,如下:

    @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
    

    #定制Banner
    ##修改Banner
    我们在启动Spring Boot项目的时候,在控制台会默认输出一个启动图案,如下:
    这里写图片描述
    当然,这个图案如果你需要的话是可以自己修改的,修改方式很简单:

    1.在src/main/resources下新建一个banner.txt文档
    2.通过http://patorjk.com/software/taag网站生成需要的字符,将字符拷贝到步骤1所创建的txt文档中,比如我这里为Hello Sang!生成字符,如下:

    这里写图片描述
    点击左下角的选择和拷贝按钮,将这个字符拷贝到txt文档中,然后再启动项目,这个时候控制台输出的文本就会自动改变,如下:
    这里写图片描述
    ##关闭Banner
    可以修改当然也可以关闭,关闭Banner需要我们稍微修改一下main方法中的代码,如下:

    public static void main(String[] args) {
    		SpringApplicationBuilder builder = new SpringApplicationBuilder(Test19SpringBoot2Application.class);
    		//修改Banner的模式为OFF
    		builder.bannerMode(Banner.Mode.OFF).run(args);
    	}
    

    OK,如此修改之后当我们再次启动Project的时候就看不到Banner了。

    #Spring Boot的配置文件
    Spring Boot使用一个全局的配置文件application.properties或者application.yml,配置文件放在src/main/resources目录下。properties是我们常见的一种配置文件,Spring Boot不仅支持properties这种类型的配置文件,也支持yaml语言的配置文件,我这里以properties类型的配置文件为例来看几个案例。

    1.修改Tomcat默认端口和默认访问路径

    Tomcat默认端口是8080,我将之改为8081,默认访问路径是http://localhost:8080,我将之改为http://localhost:8081/helloboot,我们来看看这两个需求要怎么样通过简单的配置来实现。
    很简单,在application.properties文件中添加如下代码:

    server.context-path=/helloboot
    server.port=8081
    

    然后再启动Project,在浏览器中就得这样来访问了:
    这里写图片描述

    常规属性配置

    在前面的博客( Spring常用配置 )中我们介绍了如何在使用Spring容器框架下注入properties文件里的值。如果我们使用了Spring Boot,这项工作将会变得更加简单,我们只需要在application.properties中定义属性,然后在代码中直接使用@Value注入即可。
    如下:

    book.author=罗贯中
    book.name=三国演义
    book.pinyin=sanguoyanyi
    

    我这里专门设置了中文,因为中文不做特殊处理会乱码,处理方式为继续在application.properties中添加如下代码:

    server.tomcat.uri-encoding=UTF-8
    spring.http.encoding.charset=UTF-8
    spring.http.encoding.enabled=true
    spring.http.encoding.force=true
    spring.messages.encoding=UTF-8
    

    然后 在IntelliJ IDEA中依次点击File -> Settings -> Editor -> File Encodings
    将Properties Files (*.properties)下的Default encoding for properties files设置为UTF-8,将Transparent native-to-ascii conversion前的勾选上。(参考【Springboot 之 解决IDEA读取properties配置文件的中文乱码问题】【Springboot 之 解决IDEA读取properties配置文件的中文乱码问题】)。
    然后在变量中通过@Value直接注入就行了,如下:

    	@Value(value = "${book.author}")
    	private String bookAuthor;
    	@Value("${book.name}")
    	private String bookName;
    	@Value("${book.pinyin}")
    	private String bookPinYin;
    

    修改index方法,使之返回这些值:

    @RequestMapping(value = "/",produces = "text/plain;charset=UTF-8")
    	String index(){
    		return "Hello Spring Boot! The BookName is "+bookName+";and Book Author is "+bookAuthor+";and Book PinYin is "+bookPinYin;
    	}
    

    然后在浏览器中访问,结果如下:
    这里写图片描述

    很简单吧。

    类型安全的配置

    刚刚说的这种方式我们在实际项目中使用的时候工作量略大,因为每个项目要注入的变量的值太多了,这种时候我们可以使用基于类型安全的配置方式,就是将properties属性和一个Bean关联在一起,这样使用起来会更加方便。我么来看看这种方式怎么实现。

    1.在src/main/resources文件夹下创建文件book.properties

    文件内容如下:

    book.name=红楼梦
    book.author=曹雪芹
    book.price=28
    

    2.创建Book Bean,并注入properties文件中的值

    代码如下:

    @Component
    @ConfigurationProperties(prefix = "book",locations = "classpath:book.properties")
    public class BookBean {
        private String name;
        private String author;
        private String price;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    
        public String getPrice() {
            return price;
        }
    
        public void setPrice(String price) {
            this.price = price;
        }
    }
    

    prefix是指前缀,location指定要注入文件的位置。

    3.添加路径映射

    在Controller中添加如下代码注入Bean:

    @Autowired
    	private BookBean bookBean;
    

    添加路径映射:

    @RequestMapping("/book")
    	public String book() {
    		return "Hello Spring Boot! The BookName is "+bookBean.getName()+";and Book Author is "+bookBean.getAuthor()+";and Book price is "+bookBean.getPrice();
    	}
    

    运行效果如下:

    #日志配置
    默认情况下Spring Boot使用Logback作为日志框架,也就是我们前面几篇博客中用到的打印日志方式,当然如果有需要我们可以手动配置日志级别以及日志输出位置,相比于我们在Spring容器中写的日志输出代码,这里的配置简直就是小儿科了,只需要在application.properties中添加如下代码:

    logging.file=/home/sang/workspace/log.log
    logging.level.org.springframework.web=debug
    

    上面表示配置日志输出位置,下面配置日志级别。

    #Profile配置问题
    Spring常用配置 这篇文章中,我们已经介绍了Profile的作用,已经如何在Spring框架下使用Profile,但是当时小伙伴们看到了还是稍微有点麻烦,在Spring Boot 中系统提供了更为简洁的方式。全局Profile配置我们使用application-{profile}.properties来定义,然后在application.properties中通过spring.profiles.active来指定使用哪个Profile。OK,那么接下来我们来看一个简单的案例。

    1.在src/main/resources文件夹下定义不同环境下的Profile配置文件,文件名分别为application-prod.properties和application-dev.properties,这两个前者表示生产环境下的配置,后者表示开发环境下的配置,如下:

    这里写图片描述

    application-prod.properties:

    server.port=8081
    

    application-dev.properties:

    server.port=8080
    

    然后在application.properties中进行简单配置,如下:

    spring.profiles.active=dev
    

    这个表示使用开发环境下的配置。然后运行项目,我们得通过8080端口才可以访问:
    这里写图片描述
    如果想换为生产环境,只需要把spring.profiles.active=dev改为spring.profiles.active=prod即可,当然访问端口这是也变为8081了,如下:
    这里写图片描述

    本案例下载地址:
    本项目GitHub地址

    以上。

    参考资料:
    《JavaEE开发的颠覆者 Spring Boot实战》第五章、第六章

    展开全文
  • SSH2框架搭建实例源码

    万次下载 热门讨论 2013-04-25 09:53:29
    SSH2框架搭建实例(spring3.2+strust2.3.4+hibernate4.2)全部采用最新版本.演示了用户登录和用户管理
  • 框架

    2020-07-02 15:58:06
    为什么我用了框架,却感觉不到框架的用处
  • 2018几大主流的UI/JS框架——前端框架

    万次阅读 多人点赞 2018-07-28 11:37:07
    这一年中有很多热门的前端开发框架,下面源码时代web小编为大家总结2016年至今最受欢迎的几款前端框架。 在这互联网飞速发展的信息时代,技术的更新迭代也在加快。目前看来,火了十几年的Java技术现在仍然是棵常青...

    2016年开始应该是互联网飞速发展的几年,同时也是Web前端开发非常火爆的一年,Web 前端技术发展速度让人感觉几乎不是继承式的迭代,而是一次次的变革和创造。这一年中有很多热门的前端开发框架,下面源码时代web小编为大家总结2016年至今最受欢迎的几款前端框架。

    在这互联网飞速发展的信息时代,技术的更新迭代也在加快。目前看来,火了十几年的Java技术现在仍然是棵常青树。回想两年前初来咋到,也是想好好当一名java程序员,五年计划都行想好了,最后还是阴差阳错搞了前端。前端目前来看还是非常火的,随着IT技术的百花齐放,新的前端框架不断推出,但大多都还在狂吼的阶段。其实一直以来对技术的理解是技术服务于业务和产品,产品又在不同程度的推进着技术的演进。Web、无线、物联网、VR、PC从不同方向推进着技术的融合与微创新。程序员在不同业务场景下的角色互换。而随着Node.js的出现语言的角色也在发生着转变,js扮演了越来越重要的角色。也就有了茶余饭后也把了解到的知识整理一下。

    前端UI框架组件库:

    说到前端框架我第一印象中想起React、Vue和Angular,不知道你是否与我一样想到这些,现在常用的有:Bootstrap、jQuery UI、BootMetro、AUI常用的还有很多、就不一一跟大家举例出来了,因为很多朋友认为在不同项目开发中用到的前端框架不一样,其实也有一款可以适用于多种项目开发的前端框架,只是没发现。

    用前端框架开发项目的原因?

    这个应该是最好解决的问题,首先就是减少造轮子的想法,能够快速的开发一款web应用对于公司来说都是非常愿意开到的,在时间和成本之间就能够节约很多的时间,这是其中一点,另外一点就是使用前端框架的组件功能,只要组件功能强大,什么样的项目都能够开发(前提是:要熟悉前端框架的功能!),时间成本问题就能够轻松解决。

    没有设计师也能做出精美页面效果的前端框架

    虽然市场中有很多的前端框架,但部分UI框架是属于组件库,然而QUICK UI跟当下流行的三大底层框架React、Vue和Angular不同,QUICK UI提供了一整套前端解决方案,包括前后端分离的开发框架、100多种功能强大的UI控件、几十套精美的皮肤模板和近16万字的开发文档,满足你所以开发项目都不是问题。

     

    前端框架库:

    1.Node.Js

    • 地址:http://www.runoob.com/nodejs/nodejs-tutorial.html (中文网)
    • 描述:Node.js是一个Javascript运行环境(runtime)。实际上它是对Google V8引擎进行了封装。V8引 擎执行Javascript的速度非常快,性能非常好。Node.js对一些特殊用例进行了优化,提供了替代的API,使得V8在非浏览器环境下运行得更好。

      Node.js是一个基于Chrome JavaScript运行时建立的平台, 用于方便地搭建响应速度快、易于扩展的网络应用。Node.js 使用事件驱动, 非阻塞I/O 模型而得以轻量和高效,非常适合在分布式设备上运行数据密集型的实时应用。

      简单的说 node.js 就是运行在服务端的 JavaScript

      Node.js 是一个基于Chrome javascript 运行时建立的一个平台。

      Node.js是一个事件驱动I/O服务端JavaScript环境,基于Google的V8引擎,V8引擎执行Javascript的速度非常快,性能非常好。

    • 用途:

      1. RESTful API(目前比较流行的接口开发风格)

      这是NodeJS最理想的应用场景,可以处理数万条连接,本身没有太多的逻辑,只需要请求API,组织数据进行返回即可。它本质上只是从某个数据库中查找一些值并将它们组成一个响应。由于响应是少量文本,入站请求也是少量的文本,因此流量不高,一台机器甚至也可以处理最繁忙的公司的API需求。

      2. 统一Web应用的UI层

      目前MVC的架构,在某种意义上来说,Web开发有两个UI层,一个是在浏览器里面我们最终看到的,另一个在server端,负责生成和拼接页面。

    不讨论这种架构是好是坏,但是有另外一种实践,面向服务的架构,更好的做前后端的依赖分离。如果所有的关键业务逻辑都封装成REST调用,就意味着在上层只需要考虑如何用这些REST接口构建具体的应用。那些后端程序员们根本不操心具体数据是如何从一个页面传递到另一个页面的,他们也不用管用户数据更新是通过Ajax异步获取的还是通过刷新页面。

      3. 大量Ajax请求的应用

    例如个性化应用,每个用户看到的页面都不一样,缓存失效,需要在页面加载的时候发起Ajax请求,NodeJS能响应大量的并发请求。  总而言之,NodeJS适合运用在高并发、I/O密集、少量业务逻辑的场景。

     

    2.angular.Js(比较厉害,github排名也比较高)

    • 地址:http://www.runoob.com/angularjs/angularjs-tutorial.html (中文网)
    • 描述:AngularJS[1]  诞生于2009年,由Misko Hevery 等人创建,后为Google所收购。是一款优秀的前端JS框架,已经被用于Google的多款产品当中。AngularJS有着诸多特性,最为核心的是:MVVM、模块化、自动化双向数据绑定、语义化标签、依赖注入等等。
    • 用途:通过描述我们应该就能很好的明白AngularJS的真实用途了,MVVM,模块化,自动化双向数据绑定等等。除了简单的dom操作外,更能体现Js编程的强大。当然应用应该视场合而定。
    • 它的出现比较早,也是曾经比较流行的前端js框架,但是今年来随着reactJS与VueJS的出现,它的热度在慢慢降低。

     

    3.JQuery Mobile

    • 地址:http://www.w3school.com.cn/jquerymobile/    (中文网)
    • 描述:Query Mobile是jQuery 在手机上和平板设备上的版本。jQuery Mobile 不仅会给主流移动平台带来jQuery核心库,而且会发布一个完整统一的jQuery移动UI框架。支持全球主流的移动平台。jQuery Mobile开发团队说:能开发这个项目,我们非常兴奋。移动Web太需要一个跨浏览器的框架,让开发人员开发出真正的移动Web网站。
    • 用途:jQuery Mobile 是创建移动 web 应用程序的框架。

          jQuery Mobile 适用于所有流行的智能手机和平板电脑。

          jquery Mobile 使用 HTML5 和 CSS3 通过尽可能少的脚本对页面进行布局。

     

    4.requirejs

    • 地址:http://www.requirejs.cn/
    • 描述:RequireJS的目标是鼓励代码的模块化,它使用了不同于传统<script>标签的脚本加载步骤。可以用它来加速、优化代码,但其主要目的还是为了代码的模块化。它鼓励在使用脚本时以module ID替代URL地址。

    RequireJS以一个相对于baseUrl的地址来加载所有的代码。 页面顶层<script>标签含有一个特殊的属性data-main,require.js使用它来启动脚本加载过程,而baseUrl一般设置到与该属性相一致的目录。

    • 用途:模块化动态加载。

     

    5.Vue.js(目前市场上的主流)

    • 地址:http://cn.vuejs.org/
    • 描述:Vue.js 是用于构建交互式的 Web  界面的库。它提供了 MVVM 数据绑定和一个可组合的组件系统,具有简单、灵活的 API。从技术上讲, Vue.js 集中在 MVVM 模式上的视图模型层,并通过双向数据绑定连接视图和模型。实际的 DOM 操作和输出格式被抽象出来成指令和过滤器。相比其它的 MVVM 框架,Vue.js 更容易上手。
    • 目前市场上比较流行的前后端分离的开发模式,大多前端都是vueJS做的,具体的优点请大家看官方文档。

     

    6.backbone.js

    • 地址:http://www.css88.com/doc/backbone/
    • 描述:Backbone 为复杂Javascript应用程序提供模型(models)、集合(collections)、视图(views)的结构。其中模型用于绑定键值数据和自定义事件;集合附有可枚举函数的丰富API; 视图可以声明事件处理函数,并通过RESTful JSON接口连接到应用程序。

     

    7.React.js(gihub排名仅次于vue.js)

    • 地址:http://reactjs.cn/react/docs/why-react.html
    • 描述:React 是一个 Facebook 和 Instagram 用来创建用户界面的 JavaScript 库。很多人认为 React 是 MVC 中的 V(视图)。我们创造 React 是为了解决一个问题:构建随着时间数据不断变化的大规模应用程序。为了达到这个目标,React 采用下面两个主要的思想。

    8.Amaze UI

    Amaze UI是轻量级的前端应用框架,是国内比较流行的框架,比较适用于移动端响应式开发框架,可以按照项目要求生成专属的UI框架库进行使用,组件非常丰富,可以构建出漂亮的web页面。

    官网地址:http://amazeui.org/

    三、可视化组件

    1.Echarts

    • 地址:http://echarts.baidu.com/
    • 描述:ECharts,一个纯 Javascript 的图表库,可以流畅的运行在 PC 和移动设备上,兼容当前绝大部分浏览器(IE8/9/10/11,Chrome,Firefox,Safari等),底层依赖轻量级的 Canvas 类库ZRender,提供直观,生动,可交互,可高度个性化定制的数据可视化图表。

     

    2.tableau(收费)

    • 地址:http://www.yuandingit.com/special/tableau/index.html
    • 描述:Tableau 是桌面系统中最简单的商业智能工具软件,Tableau 没有强迫用户编写自定义代码,新的控制台也可完全自定义配置。在控制台上,不仅能够监测信息,而且还提供完整的分析能力。Tableau控制台灵活,具有高度的动态性。

     

    四、前端构建工具

    1.gulp

    • 地址:http://www.gulpjs.com.cn/
    • 描述:易于使用

          通过代码优于配置的策略,Gulp 让简单的任务简单,复杂的任务可管理。

          构建快速

          利用 Node.js 流的威力,你可以快速构建项目并减少频繁的 IO 操作。

          插件高质

          Gulp 严格的插件指南确保插件如你期望的那样简洁高质得工作。

          易于学习

          通过最少的 API,掌握 Gulp 毫不费力,构建工作尽在掌握:如同一系列流管道。

    展开全文
  • SSH框架总结(框架分析+环境搭建+实例源码下载)

    万次阅读 多人点赞 2013-04-25 10:00:28
    首先,SSH不是一个框架,而是多个框架(struts+spring+hibernate)的集成,是目前较流行的一种Web应用程序开源集成框架,用于构建灵活、易于扩展的多层Web应用程序。   集成SSH框架的系统从职责上分为四层:表示层...

     

    首先,SSH不是一个框架,而是多个框架(struts+spring+hibernate)的集成,是目前较流行的一种Web应用程序开源集成框架,用于构建灵活、易于扩展的多层Web应用程序

     

    集成SSH框架的系统从职责上分为四层:表示层、业务逻辑层、数据持久层和域模块层(实体层)。

     

    Struts作为系统的整体基础架构,负责MVC的分离,在Struts框架的模型部分,控制业务跳转,利用Hibernate框架对持久层提供支持Spring一方面作为一个轻量级的IoC容器,负责查找、定位、创建和管理对象及对象之间的依赖关系,另一方面能使StrutsHibernate更好地工作。

     

     

    SSH构建系统的基本业务流程是:

     

    1在表示层中,首先通过JSP页面实现交互界面,负责传送请求(Request)和接收响应(Response),然后Struts根据配置文件(struts-config.xml)将ActionServlet接收到的Request委派给相应的Action处理。

    2在业务层中,管理服务组件的Spring IoC容器负责向Action提供业务模型(Model)组件和该组件的协作对象数据处理(DAO)组件完成业务逻辑,并提供事务处理、缓冲池等容器组件以提升系统性能和保证数据的完整性。

    3在持久层中,则依赖于Hibernate的对象化映射和数据库交互,处理DAO组件请求的数据,并返回处理结果。

     

    采用上述开发模型,不仅实现了视图、控制器与模型的彻底分离,而且还实现了业务逻辑层与持久层的分离。这样无论前端如何变化,模型层只需很少的改动,并且数据库的变化也不会对前端有所影响,大大提高了系统的可复用性。而且由于不同层之间耦合度小,有利于团队成员并行工作,大大提高了开发效率。

     

     

    下面我们再详细看一下组成SSH的这三个框架

    一、Spring

    1、什么是Spring?

    简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

     

    2、Spring的特性

    具体自己百度吧

    所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码

     

    3、为什么使用Spring?

    Spring的以上特性使得开发人员使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。

     

    二、Struts

    1、什么是Struts?

    它通过采用 Java Servlet/JSP 技术,实现了基于Java EEWeb应用的MVC设计模式的应用框架,是MVC经典设计模式中的一个经典产品。

     

    2、Struts1的核心构成

     

    在 Struts1 中,由一个名为 ActionServlet 的 Servlet 充当 控制器(Controller)的角色,根据描述模型、视图、控制器对应关系的 struts-config.xml 的配置文件,转发视图(View)的请求,组装响应数据模型(Model)。

     

    在 MVC 的模型(Model)部分,经常划分为两个主要子系统(系统的内部数据状态与改变数据状态的逻辑动作),这两个概念子系统分别具体对应 Struts 1里的 ActionForm 与 Action 两个需要继承实现超类。在这里,Struts 1可以与各种标准的数据访问技术结合在一起,包括Enterprise Java Beans(EJB), JDBC 与 JNDI。

     

    在 Struts 1的视图(View) 端,除了使用标准的JavaServer Pages(JSP)以外,还提供了大量的标签库使用,同时也可以与其他表现层组件技术(产品)进行整合,比如 Velocity Templates,XSLT 等。

     

    通过应用 Struts 的框架,最终用户可以把大部分的关注点放在自己的业务逻辑(Action)与 映射关系的配置文件(struts-config.xml)中。

     

    3、Struts1的基本执行流程

    详见《STRUTS基本工作流程》

     

    4、什么是struts2

    Struts 2是Struts的下一代产品,是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。Struts 2以WebWork为核心,采用拦截器的机制来处理用户的请求,这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开,所以Struts 2可以理解为WebWork的更新产品

     

    5、strut2的体系结构

     

     

    解析:

    当Web容器收到请求(HttpServletRequest)它将请求传递给一个标准的的过滤链包括  流程(ActionContextCleanUp)过滤器,然后经过Other filters(SiteMesh ,etc),

    接下来需要调用FilterDispatcher核心控制器,然后它调用ActionMapper确定请求那个Action,ActionMapper返回一个收集Action详细信息的ActionMaping对象。

    接下来FilterDispatcher将控制权委派给ActionProxy,ActionProxy调用配置管理器(ConfigurationManager) 从配置文件中读取配置信息(struts.xml),然后创建ActionInvocation对象,ActionInvocation在调用Action之前会依次的调用所用配置拦截器(Interceptor N) 一旦执行结果返回结果字符串ActionInvocation负责查找结果字符串对应的(Result)然后执行这个Result Result会调用一些模版(JSP)

    来呈现页面,之后拦截器(Interceptor N)会在被执行(顺序和Action执行之前相反)最后响应(HttpServletResponse)被返回在web.xml中配置的那些过滤器和(核心控制器)(FilterDispatcher)。

     

    6、为什么使用Struts?

    首先,Struts 是MVC的一种实现,它将 Servlet和 JSP 标记(属于 J2EE 规范)用作实现的一部分。Struts继承了MVC的各项特性,并根据J2EE的特点,做了相应的变化与扩展减弱了业务逻辑接口和数据接口之间的耦合,以及让视图层更富于变化

     

    另外, struts具有页面导航功能,使系统的脉络更加清晰。通过一个配置文件,即可把握整个系统各部分之间的联系,这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时,这种优势体现得更加明显。

     

    7、 Struts1和Struts2的区别

    详见《Struts1 和 Struts2

     

    三、Hibernate

    1、什么是Hibernate?

    Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任

     

    2、Hibernate核心构成

     

    具体就不展开了

     

    3、Hibernate基本执行流程

     

     

    为什么使用Hibernate?

    1. 对JDBC访问数据库的代码做了封装,大大简化了数据访问层繁琐的重复性代码。

    2、Hibernate是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作,将软件开发人员从大量相同的数据持久层相关编程工作中解放出来,使开发更对象化了。

    3、移植性好,支持各种数据库,如果换个数据库只要在配置文件中变换配置就可以了,不用改变hibernate代码。

    4、支持透明持久化,因为hibernate操作的是纯粹的(pojo)java类,没有实现任何接口,没有侵入性。所以说它是一个轻量级框架。

     

     

    最后附上SSH1和SSH2框架搭建的实例,点击即可下载

    SSH1框架搭建实例(spring2+struts1+hibernate3)采用旧版本,详见代码中注释

    SSH2框架搭建实例(spring3.2+strust2.3.4+hibernate4.2)全部采用最新版本,详见代码中注释

     

    开发环境搭建,参照我的另一篇博客

    Win7(64) + eclipse(64)+ tomcat7(64)+ jdk7(64)开发环境配置

     

     

     一些说明:
    
    索要代码的邮箱,我基本上都发过了,如果有漏发,请联系我。
    
    
    还是希望大家去csdn下载页去下载。如果速度慢,可以去这里http://pan.baidu.com/s/1eQh7FXo
    
    
    开发环境配置。http://blog.csdn.net/shan9liang/article/details/8807784
      
    在war中,找到application-common.xml。修改数据源,指定自己的数据库即可。项目部署后,会自动映射表。
      
      
    <!--配数据源 -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
    destroy-method="close">
    <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
    <property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl" />
    <property name="username" value="ssh" />
    <property name="password" value="ssh" />
    </bean>
      
    以上是oracle的配置。
    
    如果使用其他数据库,请在lib目录下,加入驱动包。并修改数据源。
    
    强烈建议:
    
    
    https://code.csdn.net/shan9liang/tgb
    这是在CSDN CODE托管的,采用ssh搭建的一个考勤管理系统,maven项目,比原来那个更规范了,建议用这个,而且我会持续更新,逐渐加入各种主流框架,相信我。
    。不过不是eclipse项目,需要手工导入eclipse,最近特喜欢用intellij。建议直接用git clone。


     

     

     

     

    展开全文
  • 1.什么是框架? 其实框架,就是别人写好了包装起来的一套工具,把你原先必须要写的,必须要做的一些复杂的东西都写好了放在那里,你只要调用他的方法,就可以实现一些本来要费好大劲的功能。形象一点说吧,假如你盖...
  • idea导入项目框架的方法

    万次阅读 多人点赞 2020-05-05 20:40:58
    学习时,使用IDEA的时候,经常需要导入项目框架,下面操作介绍如何导入项目框架。 打开需要导入的项目 打开方式: 打开 idea ,选择 Import Project 也可以进入idea后,选择 Flie --> New --> Project ...
  • 开源一个功能完整的SpringBoot项目框架

    万次阅读 多人点赞 2019-10-11 14:14:39
    最近想了解一下有关Spring Boot的开源项目,看了很多开源的框架,大多是一些demo或者是一个未成形的项目,基本功能都不完整,尤其是用户权限和菜单方面几乎没有完整的。 想到我之前做的框架,里面通用模块有:用户...
  • C#.NET NFine快速开发框架_V1.1 程序

    万次下载 热门讨论 2016-08-20 00:31:12
    NFine 是基于 C# 语言的极速 WEB + ORM 框架,其核心设计目标是开发迅速、代码量少、学习简单、功能强大、轻量级、易扩展,让Web开发更迅速、简单。能解决60%重复工作。为您节约更多时间,去陪恋人、家人和朋友。...
  • MVC+EF框架+EasyUI实现权限管理 源码程序

    万次下载 热门讨论 2012-12-13 18:53:53
    MVC+EF框架+EasyUI实现权限管理是对权限的基本操作的操作,具体的可以参看我的博客http://www.cnblogs.com/hanyinglong/
  • Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载

    万次下载 热门讨论 2014-07-21 12:06:07
    本资源对应博文:http://blog.csdn.net/zhshulin/article/details/37956105,可以通过博文进行学习,不建议下载完整源码,博文有详细教程,以及代码。
  • SSM框架——使用MyBatis Generator自动创建代码

    万次阅读 多人点赞 2014-04-17 10:18:03
    这两天需要用到MyBatis的代码自动生成的功能,由于MyBatis属于一种半自动的ORM框架,所以主要的工作就是配置Mapping映射文件,但是由于手写映射文件很容易出错,所以可利用MyBatis生成器自动生成实体类、DAO接口和...
  • SpringSpringMVCMybatis框架

    万人学习 2017-09-28 10:15:09
    Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言,绝大部分Java...
  • Java从入门到进阶+一站式学习Java框架技术
  • Android酷炫实用的开源框架(UI框架

    万次阅读 多人点赞 2015-05-17 11:39:08
    Android酷炫实用的开源框架(UI框架)前言忙碌的工作终于可以停息一段时间了,最近突然有一个想法,就是自己写一个app,所以找了一些合适开源控件,这样更加省时,再此分享给大家,希望能对大家有帮助,此博文介绍的...
  • Android第三方开源框架ImageLoader的完美Demo

    千次下载 热门讨论 2013-08-19 17:26:28
    Android第三方开源框架ImageLoader的完美Demo,很好地体现了ImageLoadr异步加载图片的优越性。
  • Flask框架

    万次阅读 2020-05-03 17:33:24
    Flask框架 一、初识Flask 二、Flask路由注册 三、Flask的HTTP请求 四、Flask视图函数 五、Flask模板 六、Flask应用数据库 七、Flask脚本 八、Flask cookie、session、闪现 九、Flask请求扩展、中间件、蓝图 十、...
  • JAVA框架项目

    千次下载 热门讨论 2014-12-09 09:57:57
    JAVA框架项目,学习java 的好文档,分享给各位
  • 本课程把我们公司团队的... 框架纯实战级,实用、简单、暴力。并支持插件化开发,功能还支持微信开发集成。 课程学完后,整个课件源代码就是一个完整的中型web前端开发框架。大家可以任意复制、学习、修改或占为己有
  • vue框架简介

    万次阅读 多人点赞 2019-06-15 04:50:36
    MVVM框架概述 什么是vue 是一套构建用户界面的渐进式(用到哪一块就用哪一块,不需要全部用上)前端框架,Vue的核心库只关注视图层 vue的兼容性 Vue.js不支持IE8及其以下版本,因为Vue.js使用了IE8...
  • SSH框架整合jar包

    千次下载 热门讨论 2012-07-10 09:54:44
    SSH框架整合jar包,手动整合三大框架,避免重复和冗余jar包出现
  • Mirai框架qq机器人教程

    万次阅读 多人点赞 2020-08-06 00:00:32
    Mirai框架qq机器人0.前言1. 安装Java 1.82.安装MiraiOk3.下载IDEA4.安装mirai插件4.创建项目5.解决代码报错6. miraiok结构7.mirai kotlin代码例子解析8.开发文档9. 一个简单的例子10. 用gradle生成插件10.在mirai中...
  • Iris框架

    万次阅读 2020-02-07 14:05:36
    Iris框架 介绍 Iris 是基于Go编写的一个快速,简单但功能齐全且非常高效的Web框架。它为您的下一个网站或 API 提供了一个非常富有表现力且易于使用的基础,可以很高效地用于后台开发。 Iris具有以下强大的特性: ...
  • 一站式玩转九大Java框架
  • 深度学习框架Tensorflow案例实战视频培训课程概况: Tensorflow是谷歌开源的深度学习(包括机器学习)框架,伴随着人工智能业的兴盛其大名早已响彻云霄。本课程从Tensorflow安装开始讲起,从基本计算结构到深度学习...
  • Unity战斗框架 技能框架

    千次阅读 热门讨论 2019-08-05 18:00:12
    Unity战斗框架 技能框架1.简介2.技能对象2.1 技能触发2.2 技能执行2.2.1 技能单元处理器2.3 技能接受2.技能流程2.1 初始化流程 1.简介 该框架基本可以概括为以下这句话: 释放某技能后,先左斩一下(播个动画放个...
  • 使用开源框架ViewPageIndicator 和 ViewPager 仿网易新闻客户端Tab标签,项目详情http://blog.csdn.net/xiaanming/article/details/10766053
  • SpringBoot日志框架

    万次阅读 2019-11-27 09:49:49
    在项目的开发中,日志是必不可少的一个记录事件的组件,所以也会相应的在项目中实现和构建我们所需要的日志框架。 而市面上常见的日志框架有很多,比如:JCL、SLF4J、Jboss-logging、jUL、log4j、log4j2、logback...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,462,178
精华内容 584,871
关键字:

框架