SSH-经典的三大框架我回来了，重新学习 J2EE 之路

最新推荐文章于 2021-06-05 12:43:05 发布

Sight1005

最新推荐文章于 2021-06-05 12:43:05 发布

阅读量2.3k

点赞数 3

分类专栏： J2EE框架文章标签： spring j2ee

本文链接：https://blog.csdn.net/anjingzuo/article/details/52330164

版权

J2EE框架专栏收录该内容

3 篇文章 0 订阅

订阅专栏

已经一年多配置过 ssh框架，借空闲时间重新试试这个经典框架，因为我就是从这里开始入门的。

本文摘自博客大神 http://blog.csdn.net/lishuangzhe7047 一个女程序员佩服佩服把她写的分享给自己记录下
1.Spring 框架
spring是J2EE应用程序框架，是轻量级的IoC和AOP的容器框架，主要是针对javaBean的生命周期进行管理的轻量级容器，可以单独使用，也可以和Struts框架，ibatis框架等组合使用。
摘自他人博客，说实话 IOC和AOP对初学者来说一脸懵逼，这是什么东西啊~那么深奥！！其实不必要去深究什么，一个框架的里会帮处理好后顾之忧
以前代码是这样写的

//dao层对象  
public class UserDao{  
   publicvoid insert(User user){}  
}  

//service层对象  
public classUserService{  
   publicvoid insert(User user){  
       UserDaouserdao = new UserDao();  
       userdao.insert(user);  
   }  
}

现在加入spring 之后是这样写的

//dao层对象  
public class UserDao{  
    publicvoid insert(User user){}  
}  
//service层对象  
public classUserService{  
   private UserDao userdao;  

   publicUserDao getUserdao() {  
      returnuserdao;  
   }  
   publicvoid setUserdao(UserDao userdao) {  
      this.userdao= userdao;  
   }  

   publicvoid insert(User user){  
      userdao.insert(user);  
   }  

}

瞬间就一目了然了，至于对象是怎么创建关系是什么组合都是有 spring来处理

spring中的注解就免去写 xml文件的方便
spring框架使用的是分层的注解。
持久层：@Repository；
服务层：@Service
控制层：@Controller
@Repository 等同于配置文件中的

<bean id="userDao" class="com.lsz.spring.UserDao" />

@Service注解等同于

<bean id="testService" class="com.lsz.spring.UserService" />

@Resource 对象间关系的组合，默认采用的是byName方式进行装配，如果根据名称查找不到关联的对象，那么会再采用byType继续查找。

@Service(value="testService")  
public classTestService {  

@Resource//相当于自动装配  
private UserDao userDao ;  
      public UserDao getUserDao() {  
              returnuserDao;  
      }  
      public void setUserDao(UserDao userDao) {  
             this.userDao= userDao;  
      }  

}

@Controller(value=”ua”)

<bean id="ua" class="com.lsz.spring.UserAction " />

从Spring环境中获取Action对象，此处被坑了好久好久备注下~

ServletContext application =request.getSession().getServletContext();  
ApplicationContextac = WebApplicationContextUtils.getWebApplicationContext(application);  

UserAction useraction = (UserAction)ac.getBean("ua");//获取控制层对象  

response.setContentType("text/html;charset=GBK");//设置编码  
PrintWriter out =response.getWriter();  

//分别将三个层的对象打印出来。  
out.println("Action:"+userAction);  
out.println("Service:"+userAction.getUserService());  
out.println("Dao:"+userAction.getUserService().getUserDao());

AOP(Aspect-OrientedProgramming)面向方面编程
实例：设置字符编码格式看作是一个Aspect方面，而拦截器就是一个Advice增强。

<span style="font-size:18px;"><!-- 字符编码过滤器-->  
<filter>  
<filter-name>characterFilter</filter-name>  
<filter-class>com.bjpowernode.egov.filter.CharacterEncodingFilter</filter-class>  
</filter>  
<filter-mapping>  
<filter-name>characterFilter</filter-name>  
<url-pattern>/servlet/*</url-pattern>  
</filter-mapping>  
 </span>  
过滤器类
这样就不用在每个servlet中设置编码拉

public class CharacterEncodingFilter implements Filter {

@Override
public void destroy() {}

@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChainchain) throws IOException, ServletException {
request.setCharacterEncoding(“GB18030”);
chain.doFilter(request,response);
}

@Override
publicvoid init(FilterConfig filterConfig) throws ServletException {}
}
Spring框架中使用AOP的优点
Aop与spring的IOC容器整合，增强，切入点都是javabean，可以在同一文件中配置
和spring的其他部分一样，可以在不同应用服务器之间任意移植
spring实现Aop的拦截接口，使得用户不必绑定在特定的拦截器接口上
aop面向切面的编程思想，打破面向对象的思维方式，更要学习面向切面的这种思想。
2.Struts2框架介绍
Struts2框架是MVC流程框架，适合分层开发。框架应用实现不依赖于Servlet，使用大量的拦截器来处理用户请求，属于无侵入式的设计。

Struts2框架的流程原理
1）请求先到达Filter中央控制器
2）然后为Action创建代理类
3）将各个服务存放在拦截器中，执行完拦截器后再去执行action类行action类，action类调用service，再调用dao
4）得到结果字符串，创建result对象
5）转向相应的视图。
这是整个流程图
Struts2框架中的Action类是一个单独的javabean对象。不像Struts1中还要去继承HttpServlet，耦合度减小了。
1，流程
拦截器拦截请求，创建代理Action对象，执行方法，返回结果，界面跳转。
拦截器解析请求路径，获取Action的名称，到配置文件中查找action的完整类名，利用反射创建对象。
每请求一次，就创建一个对象，所以action是多例的，也是线程安全的。
url
2.数据传递
框架将Http对象和包装后的Map集合对象都存放到ActionContext上下文对象集合中。所以可以根据ActionContext来获取想要使用的对象。

ActionContext ac = ActionContext.getContext(); //上下文对象相当于request范围  
HttpServletRequest request =(HttpServletRequest)ac.get(StrutsStatics.HTTP_REQUEST);  
HttpSession session = request.getSession(false);  
ServletContext application = session.getServletContext();  
ServletContext application = ac.get(StrutsStatics.SERVLET_CONTEXT);  
HttpServletRequest request = ServletActionContext.getRequest(); (推荐使用)  
HttpServletResponse response =ServletActionContext.getResponse();

2，获取Map集合

ActionContext ac = ActionContext.getContext();  
Mapsession = ac.getSession();  
Mapsession2 =(Map)ac.get("session");  
Mapsession3=(Map)ac.get(ActionContext.SESSION);          
Mapapplication = ac.getApplication()  
Mapapplication = ac.get(ActionContext.APPLICATION);  
Mapapplication = ac.get("application");

3，获取值栈对象以及参数集合对象

ActionContext ac = ActionContext.getContext();  
ValueStack vs = ac.getValueStack();  
Map paramts = ac.getParameters();

四：数据的显示
El表达式的形式，取request对象中的值
${requestScope.username }

而这种表达式的方式可以表示成java代码的方式：
<%
Stringusername =(String)request.getAttribute(“username”);//被重写的方法，底层是通过ognl查询值栈中的数据
out.print(username);
%>
从request返回取数据，实质上底层是通过Ognl语言操作值栈中的数据。 ActionContext对象的集合和OgnlValueStack值栈的集合为同一个集合对象，所以从值栈的Map集合中取数据，就相当于从ActionContext上下文中取数据。

3.Hibernate框架学习
Hibernate框架主要是实现数据库与实体类间的映射，使的操作实体类相当与操作hibernate框架。
只要实体类写好配置文件配好，就能实现和数据库的映射，其中实体类对应表，类的属性对应数据库的表字段。这样就不用管数据库的相关操作了。

多对一映射，如学生和班级之间的关系，多个学生对应一个班级。
1，对象模型中是在多的一方对象中加入一的一方对象的引用。配置文件参见上图所示。
2，注解使用

@Entity  
public class Person {  
    private int id;  
    private String name;  
    private IDCard cid;  

    @ManyToOne  
    @JoinColumn(name="cardid")  
    public IDCard getcid() {  
        return cid;  
    }

用@JoinColumn来指定外键的字段名
一对多的映射，如班级和学生的关系，一个班级中有多个学生。
1，对象模型中是在一的一端添加Set集合，包含多的一端。

public class Classes{  

    private int cid ;  
    private String cname ;  

    <strong>private Set<Student> studentSet = new HashSet<Student>(); /</strong>/一对多  

    public int getCid() {  
        return cid;  
    }  
    public void setCid(int cid) {  
        this.cid = cid;  
    }  
    public String getCname() {  
        return cname;  
    }  
    public void setCname(String cname) {  
        this.cname = cname;  
    }  
    public Set<Student> getStudentSet() {  
        return studentSet;  
    }  
    public void setStudentSet(Set<Student> studentSet) {  
        this.studentSet = studentSet;  
    }  
}

2，配置文件
1）在多的一端课程，使用set标签并使用one-to-many标签
2）在一的一端学生，使用many-to-one标签

@OneToMany//进行注解为一对多的关系  
@JoinColumn(name="classesId")//在多的一端注解一个字段(名为classessid)  
public Set<Student> getStudents() {  
    return students;  
       }

三：多对多
多对多映射关系，还拿学生课程关系，多个学生对应多个课程，多个课程对应多个学生
1，在对象模型中是双方都加入set集合
2，xml配置文件中，双方也都用set标签和many-to-many标签
3，注解

@ManyToMany  
    @JoinTable(name="t_s_c",//使用@JoinTable标签的name属性注解第三方表名称  
        joinColumns={@JoinColumn(name="courseId")},  
    //使用joinColumns属性来注解当前实体类在第三方表中的字段名称并指向该对象  
        inverseJoinColumns={@JoinColumn(name="studentId")}    
   //使用inverseJoinColumns属性来注解当前实体类持有引用对象在第三方表中的字段名称并指向被引用对象表  
)  
public Set<Student> getStudents() {return Students;}