软件体系结构 & 架构技术知识点总结（建议收藏）

Posted 二哈喇子！

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了软件体系结构 & 架构技术知识点总结（建议收藏）相关的知识，希望对你有一定的参考价值。

文章目录

页面技术

提示：这里可以添加本文要记录的大概内容：

JSP（web服务器端技术）、JSTL标签库、EL表达式、bootstrap页面模板（静态html、CSS、JS））
采用传统开发模式时，页面需要用到jsp技术（JSTL标签库、EL表达式）。

前后端分离的开发模式，页面使用VUE框架，后端服务使用SSM或者是SpringBoot。

EL表达式的思维导图如下：

提示：以下是本篇文章正文内容，下面案例可供参考

一、Spring框架

1. 三层体系架构

在实际开发中，通常服务器端在采用分层方式进行架构。三层体系架构，分别为表示层(Web层，包括控制层，使用SpringMVC框架)、业务逻辑层(Service，使用Spring框架)、持久层(数据访问层，Dao，使用Mybatis框架)， Spring对每一层都提供了技术支持。

2. Spring的核心

Spring的核心是控制反转（IoC： Inverse of Control ）和面向切面编程（AOP： Aspect Oriented Programming ）。
在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。

IoC的全称是Inversion of Control，中文名称为控制反转。控制反转就是指在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到了Spring容器，控制权发生了反转。

DI的全称是Dependency Injection，中文称之为依赖注入。它与控制反转（IoC）的含义相同，只不过这两个称呼是从两个角度描述的同一个概念。从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入。

3. Spring 的Bean中主要的装配方式

Spring 的Bean中主要包含三种装配方式，分别为基于XML的装配，基于Annotation的装配和自动装配，这三种装配方式的用法如下：

（1）基于XML的装配：

Spring提供了2种基于XML的装配方式：设值注入（Setter Injection）和构造注入（Constructor Injection）。
一种是属性setter方法注入（或设值注入），另一种是构造方法注入。属性setter方法注入是指IoC容器使用setter方法来注入被依赖的实例。通过调用无参构造器或无参静态工厂方法实例化Bean后，调用该Bean的setter方法，即可实现基于setter方法的依赖注入。属性setter方法注入的必备条件如下：

Bean类必须有一个无参构造方法

Bean类必须为属性提供setter方法

在配置文件中，使用<property>元素来为每个属性注入值

设置注入中的Bean类必须提供一个默认的无参构造方法，同时必须为需要注入的属性提供对应的setter方法。使用设值注入时，在Spring配置文件中，需要使用<bean>元素的子元素<property>来为每个属性注入值。使用构造注入时，在配置文件里，需要使用<bean>元素的子元素<constructor-arg>来定义构造方法的参数，可以使用其value属性（或子元素）来设置该参数的值。
构造方法注入是指IoC容器使用构造方法来注入被依赖的实例。基于构造方法的依赖注入通过调用带参数的构造方法来实现，每个参数代表着一个依赖。要求必须满足如下条件：

Bean类必须提供有参构造方法

配置文件中，使用元素来为参数注入值

（2）基于Annotation的装配：

使用基于Annotation的装配时，首先需要使用@Repository、@Service与@Controller分别对实现类进行标注，然后用@Autowired或@Resource注解对注入的Bean的属性进行标注，最后在Spring的配置文件中，通过<context:annotation-config />来开启注解处理器，或使用<context:component-scan base-package="Bean所在的包路径"/>的配置方式即可实现Annotation的装配。

@Controller通常作用在控制层，用于将控制层的类标识为Spring中的Bean。

@Service通常作用在业务层，用于将业务层的类标识为Spring中的Bean。

@Repository通常作用在数据持久层（或数据访问层，DAO层），用于将数据持久层的类标识为Spring中的Bean。

@Autowired或@Resource注解对注入的Bean的属性进行标注，用于将实例化后对象注入到Bean的属性中，实现依赖注入。

（3）自动装配：

在<bean>元素中使用 autowire属性，并将其属性值设置为 byName或者 byType即可实现自动装配。

4. Spring框架的优点如下：

（1）非侵入式设计：Spring是一种非侵入式（non-invasive）框架，它可以使应用程序代码对框架的依赖最小化。
（2）方便解耦、简化开发：Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护工作都交给Spring容器管理，大大的降低了组件之间的耦合性。
（3）支持AOP：Spring提供了对AOP的支持，它允许将一些通用任务，如安全、事务、日志等进行集中式处理，从而提高了程序的复用性。
（4）支持声明式事务处理：只需要通过配置就可以完成对事务的管理，而无需手动编程。
（5）方便程序的测试：Spring提供了对Junit4的支持，可以通过注解方便的测试Spring程序。
（6）方便集成各种优秀框架：Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持。
（7）降低了Java EE API的使用难度：Spring对Java EE开发中非常难用的一些API（如：JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

5. Spring框架包：

Spring开发所需的jar包分为两个部分： Spring框架4个核心基础包和一个第三方依赖包。

spring-core-4.3.6.RELEASE.jar
包含Spring框架的核心工具类，Spring其它组件都要用到这个包里的类。

spring-beans-4.3.6.RELEASE.jar
所有应用都要用到的JAR包，它包含访问配置文件、创建和管理Bean以及进行控制反转或者依赖注入操作相关的所有类。

spring-context-4.3.6.RELEASE.jar
提供了在基础IoC功能上的扩展服务，还提供了许多企业级服务的支持

spring-expression-4.3.6.RELEASE.jar
定义了Spring的表达式语言。

在使用Spring开发时，除了要使用自带的JAR包外，Spring的核心容器还需要依赖一个第三方包commons.logging的JAR包。

6. ApplicationContext容器

通常在Java项目中，通常会通过ClassPathXmlApplicationContext类来实例化ApplicationContext容器的方式，而在Web项目中，ApplicationContext容器的实例化工作会交由Web服务器来完成。

7. SpringIOC应用示例核心代码：

main方法：

public class Test 

	public static void main(String[] args) 
		ApplicationContext context = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		
		UserService userService = (UserService) context.getBean("userService");
		User user = new User();
		user.setId("11111");
		user.setName("zhangsan22222");
		userService.addUser(user);

applicationContext.xml

<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-3.0.xsd">
    <!--配置bean,配置后该类由spring管理-->  
	<bean id="userService" class="spring.ioc.service.UserService">
	    <!--依赖注入,配置当前类中相应的属性-->  
	    <!-- <property>标签中的name就是UserService类中的userDao属性名，ref指下面<bean name="userDao"...>，这样其实是spring将UserDaoImp对象实例化并且调用UserService的setUserDao方法将UserDao注入 -->
		<property name="userDao" ref="userDaoImp"></property>
	</bean>
	<!—配置bean ，,配置后该类由spring管理-->
	<bean id="userDaoImp" class="spring.ioc.dao.imp.UserDaoImp"></bean>

</beans>

UserService.java

public class UserService 
	public UserDao userDao;
	public UserDao getUserDao() 
		return userDao;
	
	public void setUserDao(UserDao userDao) 
		this.userDao = userDao;
	
	public void addUser(User user)
		userDao.addUser(user);

UserDaoImp.java

public class UserDaoImp implements UserDao
	public void addUser(User user)
		System.out.println("添加了一个用户，姓名是"
	        +user.getName()+user.getId());

二、SpringJDBCTemplate

1. 在Spring的配置文件中配置JDBC

在Spring的配置文件中配置JDBC时，需要定义了三个Bean，分别是dataSource、jdbcTemplate和需要注入类的Bean。在定义jdbcTemplate时，需要将dataSource注入到jdbcTemplate中，而其他需要使用jdbcTemplate的Bean，也需要将jdbcTemplate注入到该Bean中，这样配置完成后，Spring JDBC就可以使用了。

2. JdbcTemplate类

Spring框架提供了JdbcTemplate类，该类是Spring框架数据抽象层的基础。JdbcTemplate类是Spring JDBC的核心类。JdbcTemplate的直接父类是抽象类JdbcAccessor，实现了接口JdbcOperations。
在JdbcTemplate类中，提供了大量的更新和查询数据库的方法，使用这些方法来操作数据库，其常用的方法包括execute()、update()和query()。
其中execute()方法能够完成执行SQL语句的功能，update()方法可以完成插入、更新和删除数据的操作，query()方法可以用来处理各种对数据库表的查询操作。

3. dataSource配置

dataSource配置，即JDBC连接数据库时需要4个基本属性，包括有driverClassName、url、username和password。

4. Spring 为JDBC提供了三个模板类供选择：

JdbcTemplate：最基本的Spring JDBC模板，支持简单的JDBC数据访问功能及基于索引参数的查询。使用占位符（？）绑定参数。

NamedParameterJdbcTemplate：该模板查询时可以将值以命名参数（：参数名）的形式绑定到SQL中，而不是使用简单的索引参数。

SimpleJdbcTemplate：该模板利用Java5的一些特性如自动装箱、泛型以及可变参数列表来简化JDBC模板的使用。

5. SpringJDBCTemplate应用示例核心代码：

Main方法：

    public static void main( String[] args )
    	Test test = new Test();
    	UserAction userAction = test.getController();
    	test.testAdd(userAction);
//    	test.testFindNumbers(userAction);
//    	test.testFindNameById(userAction);
//    	test.testFindUser(userAction);
//    	test.testFindAll(userAction);
//    	test.testFindMapUser(userAction);
//    	test.testFindMapAll(userAction);
    
    public UserAction getController()
    	ApplicationContext context = 
        		new ClassPathXmlApplicationContext("config/applicationContext.xml");
    	UserAction userAction = (UserAction) context.getBean("userAction");
    	return userAction;
    
    
    public void testAdd(UserAction userAction)
    	User user  =new User();
    	user.setId(7);
    	user.setName("张三");
    	user.setAge(20);
    	userAction.add(user);
    
    
    public void testFindNumbers(UserAction userAction)
    	int numbers = userAction.findNumbers();
    	System.out.println("findNumbers方法的查询结果：");
    	System.out.println("共有"+numbers+"个用户！");
    
    
    public void testFindNameById(UserAction userAction)
    	String name = userAction.findNameById(1);
    	System.out.println("findNameById方法的查询结果：");
    	System.out.println("学号为1的学生的姓名为："+name);
    
    
    public void testFindUser(UserAction userAction)
    	System.out.println("findUser方法的查询结果：");
    	User user  = userAction.findById(1);
    	System.out.println("id："+user.getId()
    	+",name:"+user.getName()
    	+",age:"+user.getAge());
    

    public void testFindAll(UserAction userAction)
    	List<User> users  = userAction.findAll();
    	System.out.println("findAll方法的查询结果：");
    	for(User user:users)
	    	System.out.println("id："+user.getId()
	    	+",name:"+user.getName()
	    	+",age:"+user.getAge());
    	
    

    public void testFindMapUser(UserAction userAction)
    	System.out.println("findMapUser方法的查询结果：");
    	Map<String,Object> user  = userAction.findMapById(1);
    	System.out.println("id："+user.get("id")
    	+",name:"+user.get("name")
    	+",age:"+user.get("age"));
    

    public void testFindMapAll(UserAction userAction)
    	System.out.println("findMapAll方法的查询结果：");
    	List<Map<String,Object>> users  = userAction.findAllMap();
    	for(Map<String,Object> user:users)
        	System.out.println("id："+user.get("id")
        	+",name:"+user.get("name")
        	+",age:"+user.get("age"));

applicationContext.xml

<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-3.0.xsd">

	<bean id="userAction" class="action.UserAction">
		<property name="userService" ref="userService" />
	</bean>

	<bean id="userService" class="service.UserService">
		<property name="userDao" ref="userDao" />
	</bean>
	<bean id="dataSource1"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">

		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/spring" />
		<property name="username" value="root" />
		<property name="password" value="root" />
	</bean>
	<bean id="userDao" class="dao.UserDao">
		<property name="jdbcTemplate" ref="jdbcTemplate1" />
		<property name="npjt" ref="namedParameterJdbcTemplate" />
	</bean>
	<bean id="jdbcTemplate1" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource1" >
		</property>
	</bean>
	<!-- NamedParameterJdbcTemplate配置 -->
    <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
		<constructor-arg ref="jdbcTemplate1" />
	</bean>

</beans>

UserAction.java

public class UserAction 
	private UserService userService;

	public UserService getUserService() 
		return userService;
	

	public void setUserService(UserService userService) 
		this.userService = userService;
	

	public void add(User user) 
		userService.add(user);
	

	public String findNameById(int id) 
		return userService.findNameById(id);
	

	public int findNumbers() 
		return userService.findNumbers();
	

	public List<User> findAll() 
		return userService.findAll();
	

	public User findById(int id) 
		return userService.findById(id);
	

	public Map<String, Object> findMapById(int id) 
		return userService.findMapById(id);
	

	public List<Map<String, Object>> findAllMap() 
		return userService.findAllMap();

UserService.java

public class UserService 
	private UserDao userDao;

	public UserDao getUserDao() 
		return userDao;
	

	public void setUserDao(UserDao userDao) 
		this.userDao = userDao;
	

	public void add(User user) 
		userDao.add(user);
	

	public String findNameById(int id) 
		return userDao.findNameById(id);
	

	public int findNumbers() 
		return userDao.findNumbers();
	

	public List<User> findAll() 
		return userDao.findAll();
	

	public User findById(int id) 
		return userDao.findById(id);以上是关于软件体系结构 & 架构技术知识点总结（建议收藏）的主要内容，如果未能解决你的问题，请参考以下文章
 

 软件体系架构在工作中的总结


 软件体系结构知识点总结（更新中）


 [架构之路-90]：《软件架构设计：程序员向架构师转型必备》-1-总结


 [架构之路-90]：《软件架构设计：程序员向架构师转型必备》-0-总结


 计算机网络知识体系总结❤️入门篇❤️（熬夜肝文，建议收藏）


 Camera知识体系架构之驱动&应用&调试学习笔记-以瑞芯微RV1109为例